• 1 carte STM32F103C8T6 (Blue Pills)
• 1 adaptateur Série (pour charger le bootloader)
• 1 câble micro-USB
• + de quoi souder

• Wiki : http://wiki.stm32duino.com/index.php?title=Blue_Pill
• Pinout : http://reblag.dk/wordpress/wp-content/uploads/2016/07/The-Generic-STM32F103-Pinout-Diagram.pdf
• Site de ST : http://www.st.com/en/microcontrollers/stm32-32-bit-arm-cortex-mcus.html?querycriteria=productId=SC1169
• Projet à base de STM : https://www.hackster.io/paramaggarwal/converting-an-stm32f103-board-to-a-black-magic-probe-e701d4
• Forum : http://www.stm32duino.com/

stm32flash.exe -w generic_boot20_pc13.bin COM3

void setup() { 
}

void loop() {  
}

[PA0]----[220 Ohm]----|>|----[G]

#define LED PA0

void setup() { 
  pinMode(LED, OUTPUT);
}

void loop() {
  digitalWrite(LED, HIGH);
  delay(1000);
  digitalWrite(LED, LOW);
  delay(1000);
}

[3V3]----[Bouton]----[PA1]

                                               |--[10k Ohm]----[G]

#define LED PA0
#define BOUTON PA1

void setup() { 
  pinMode(LED, OUTPUT);
  pinMode(BOUTON, INPUT);
}

void loop() {
  if( digitalRead(BOUTON) == HIGH)
  {
    digitalWrite(LED, HIGH);
  }
  else
  {
    digitalWrite(LED, LOW);
  }
}

#define LED PA0
#define BOUTON PA1
#define POTENTIOMETRE PA2

void setup() { 
  pinMode(LED, OUTPUT);
  pinMode(BOUTON, INPUT);
  pinMode(POTENTIOMETRE, INPUT);

  Serial.begin(9600);
}

void loop() {
  Serial.print("Bouton : "); Serial.print(digitalRead(BOUTON));
  Serial.print(" | Potentiometre : "); Serial.println(analogRead(POTENTIOMETRE));
  if (Serial.available() > 0)
  {
    if (Serial.readString() == "1")
    {
      digitalWrite(LED, HIGH);
    }
    else
    {
      digitalWrite(LED, LOW);
    }
  }
}

#include <Servo.h>

#define LED PA0
#define BOUTON PA1
#define POTENTIOMETRE PA2
#define PIN_SERVO PA3

Servo servo;

void setup() { 
  pinMode(LED, OUTPUT);
  pinMode(BOUTON, INPUT);
  pinMode(POTENTIOMETRE, INPUT);
  servo.attach(PIN_SERVO);

  Serial.begin(9600);
}

void loop() {
  Serial.print("Bouton : "); Serial.print(digitalRead(BOUTON));
  Serial.print(" | Potentiometre : "); Serial.println(analogRead(POTENTIOMETRE));

  servo.write( map(analogRead(POTENTIOMETRE), 0, 4095, 0, 180) ); //Conversion en degrès
  
  if (Serial.available() > 0)
  {
    if (Serial.readString() == "1")
    {
      digitalWrite(LED, HIGH);
    }
    else
    {
      digitalWrite(LED, LOW);
    }
  }
}

• Un pistolet à colle chaude
• 7 crayons à papier
• Un bouchon de stylo (ou tout autre élément cylindrique avec un diamètre légèrement supérieur aux crayons)
• Un petite vis et un tournevis
• 2 pinces à linges

• Deux boutons (nommés C et Z)
• Un joystique (malheureusement, les coins sont difficilement atteignables)
• Un accéléromètre 3 axes
• Une bonne longueur de câble

Le tout dans une manette que je trouve très agréable à tenir en main, comparé à une breadboard sur laquelle ont aurait mis les composants , ainsi qu'une exploitation des données très facile grâce aux bibliothèques. De plus, aucune soudure n'est nécessaire si vous souhaitez l'utiliser sur votre arduino que temporairement.

Comment ?
Le câblage :

Afin d'utiliser la manette avec votre Arduino, prenez le connecteur de la manette de face :

 
Vous n'aurez besoin que de 4 câbles, à brancher comme ceci sur la manette :

Et il vous suffit juste de les raccorder aux pins de votre Arduino indiqués sur la photo.

Attention à bien choisir le pin d'alimentation, on utilise ici du 3,3V.

Coté programmation, la bibliothèque :

Il en existe plusieurs mais celle que j'ai choisi d'utiliser se nomme ArduinoNunchuk, écrite par Gabriel Bianconi. Elle n'est plus maintenue mais comporte tout ce dont il vous faut et elle fonctionne facilement. Il vous suffit de télécharger l'archive puis de copier le dossier ArduinoNunchuk dans le dossier nommé libraries d'Arduino.
Dès que ceci est fait, vous pouvez commencer à l'utiliser, pour commencer ajoutez ceci en haut de votre programme :

#include

Puis avant la boucle setup(), attribuez un nom à votre nunchuk, comme vous l'auriez fait pour un servomoteur, il vous faut donc ajouter ceci :

ArduinoNunchuk wii = ArduinoNunchuk();

N'hésitez pas à modifier le nom "wii" par celui que vous souhaitez mais n'oubliez pas de le remplacer par la suite aussi.

Ensuite, il vous suffit d'écrire ceci dans la fonction setup:

wii.init();

Et votre carte Arduino est prête à recevoir les informations de la Nunchuk.

Enfin, écrivez ceci avant chaque lecture de données provenant de la manette afin de les mettre à jour :

wii.update();

Et voici comment lire et afficher sur l'interface série les différentes informations (il vous faudra ajouter le "wii.update()" au tout début) :

Serial.print(wii.analogX, DEC); //Haut/Bas du joystique --> wii.analogX
  Serial.print(' ');
  Serial.print(wii.analogY, DEC); //Gauche/Droite du Joystique --> wii.analogY
  Serial.print(' ');
  Serial.print(wii.accelX, DEC);
  Serial.print(' ');
  Serial.print(wii.accelY, DEC); 
  Serial.print(' ');
  Serial.print(wii.accelZ, DEC); 
  Serial.print(' ');
  Serial.print(wii.zButton, DEC); //Renvoie un 0 si on appuie pas sur le bouton Z ou un 1 si on appuie dessus
  Serial.print(' ');                    // ---> wii.ZButton
  Serial.println(wii.cButton, DEC); //Renvoie un 0 si on appuie pas sur le bouton C ou un 1 si on appuie dessus
                                        // ---> wii.CButton

(Morceau de code du programme d'exemple)

Exemples d'utilisations de la nunchuk :

Un des exemples qui m'a pousser à utiliser cette manette est le contrôle d'un servomoteur grâce à un axe de l'accéléromètre, ça tombe bien, les deux exemples que je vais vous montrer utilisent des servomoteurs.
 
Exemple n°1 avec 1 servo :
Le but ici est de contrôler un servomoteur avec un des axes de la manette, pour cela j'ai ajouter au montage existant (décrit plus haut) un servomoteur SG90 dont le contrôle se fait via le pin 9.
 
Voici à quoi ressemble le montage :

 
Ainsi que le programme que j'ai utilisé :
 

//Bibliothèques 
#include "Servo.h"
#include 
#include 

// Nunchuk:
ArduinoNunchuk wii = ArduinoNunchuk();
int axeY;

//Servo du bas :
Servo servoBas;
int pinServoBas = 9;
int servoBasInit = 90;

void setup() {
//Initialisation des servos :
  servoBas.attach(pinServoBas);
  servoBas.write(servoBasInit);

//Initialisation de la nunchuk et de la liaison série
  wii.init();
  Serial.begin(9600);
}

void loop() {

  wii.update();

//Accélérateur Y -> Servo du bas:
  axeY = wii.accelY, DEC;
     Serial.println(axeY);
  axeY = map(axeY, 330, 700, 0, 180);
  servoBas.write(axeY);


delay(30);
}

 
Et la petite démonstration qui va avec :
 

Exemple n°2 avec 2 servos :
Exemple de programme pour contrôler 2 servomoteurs (ici de même axe), l'un avec un axe de l'accéléromètre et l'autre avec un axe du joystick. Les 2 servos sont disposés comme ceci :
 


 

 
Ainsi que le programme, dont le second servo se contrôle via le pin 10 :

//Bibliothèques
#include "Servo.h"
#include 
#include 

// Nunchuk:
ArduinoNunchuk wii = ArduinoNunchuk();
int axeY,jY;

//Servo du bas :
Servo servoBas;
int pinServoBas = 9;
int servoBasInit = 90;

//Servo du haut :
Servo servoHaut;
int pinServoHaut = 10;
int servoHautInit = 90;

void setup() {
//Initialisation des servos :
  servoBas.attach(pinServoBas);
  servoBas.write(servoBasInit);
  servoHaut.attach(pinServoHaut);
  servoHaut.write(servoHautInit);

//Initialisation de la nunchuk et de la liaison série
  wii.init();
  Serial.begin(9600);
}

void loop() {

  wii.update();

//Accélérateur Y -> Servo du bas:
  axeY = wii.accelY, DEC;
     Serial.print(axeY);
     Serial.print(" ");
  axeY = map(axeY, 330, 700, 0, 180);
  servoBas.write(axeY);

//Joystick Y (nommé jY) -> Servo du haut
  jY = wii.analogY, DEC;
     Serial.println(jY);
  jY = map(jY, 220, 30, 0, 180);
  servoHaut.write(jY);


delay(30);
}

Ainsi que la démonstration :

 
Idées supplémentaires :
Si vous souhaitez aller plus loin dans l'utilisation de la Nunchuk voici quelques idées d'utilisation :

• Contrôler sa souris ou des touches de clavier (pour contrôler l'avion dans Google Earth par exemple)
• Contrôler une base roulante (ou un robot comme celui d'Ashira par exemple)
• Contrôler une caméra à distance

Bref, les possibilités sont nombreuses.
 
Voilà tout pour ce billet, j'espère qu'il vous aura plu
 
A bientôt !

void nomFonction() {
    #Votre code
}

nomFonction();

Veillez à respecter les conditions de vos datasheets, j'en ai déjà fait les frais ...

• Servo votre_nom_de_servo;       #A déclaré avant la fonction setup;
• votre_nom_de_servo.attach(9);  #A déclaré dans la fonction setup() n'oubliez pas de modifier le "9" avec le numéro de votre pin PWM;
• votre_nom_de_servo.write(position);   #A mettre là où vous le souhaitez elle permet de faire atteindre au servo un certain angle, n'oubliez pas de mettre un delay après cette fonction afin de laisser le temps au servo d'atteindre la position donnée.

  // Librairies :
#include <Servo.h>
  // Pins E/S :
  Servo servo;
int potent = A0;
  // Variables :
int pos = 90;
int val = 90;
  //Fonction d'initialisation
void setup() {
  // Déclaration E/S :
pinMode(potent, INPUT);
  // Servomoteur(s) :
servo.attach(9);
  // Connectique :
Serial.begin(9600);
}

  // Boucle inifinie :
void loop() {
  val = analogRead(potent);
  pos = map(val, 0, 1024, 0, 180);
  servo.write(pos);
  Serial.print("Position :");
  Serial.println(pos);
  delay(10);
}

void setup() {

  Serial.begin(9600);

}

void loop() {

}

Serial.print(var); //Pour afficher une variable
Serial.print("Texte"); // Pour afficher du texte

Serial.println(var);

void loop() {

int mail = Serial.available();
if (mail > 0) {
  //Faire ceci
}
}

void loop() {

int mail = Serial.available();
int num = 8;
if (mail > 0) {

  if (Serial.read() == 8) {
    //Faire ceci
  }
  else {
  delay(10);
  }
}

}

  // Pins E/S :
int led = 13;
  // Variables :
String msg;
int mail;

  //Fonction d'initialisation
void setup() {
  
  // Déclaration E/S :
pinMode(led, OUTPUT);

  // Connectique :
Serial.begin(9600);
}

  // Boucle inifinie :
void loop() {
  mail = Serial.available();
if (mail > 0) {
  msg = Serial.readString();
 Serial.print(msg);
 Serial.println(" Recu");
 if (msg == "ON") {
  digitalWrite(led, HIGH);
  Serial.print(msg);
  Serial.println(" OK");
 }
 else if (msg == "OFF") {
  digitalWrite(led, LOW);
  Serial.print(msg);
  Serial.println(" OK");
 }
 else {
  Serial.println("Commande inconnue");
 }
}

}

Vous pouvez retrouver cet exemple en simulation ici, avec le câblage et le programme déjà fait afin que vous poussiez le tester.

• Mauvais choix du type de variable (j'ai préféré choisir une variable String car la fonction Serial possède une fonction .readString )
• LED branchée dans le mauvais sens.
• Oublie du pinMode
• Nombres de bauds différents ou non déclarés

• Ils permettent de mieux comprendre ce que doit faire votre programme donc si vous avez besoin d'aide une personne extérieure pourras vous aider plus facilement
• Ils permettent d'identifier les structures que vous allez utiliser
• Ils peuvent être facilement traduits pour n'importe quel langage et donc processeur, il est donc plus facile de migrer son programme.

Pour en créer facilement vous pouvez utiliser le logiciel nommé Dia (disponible sous Windows et Linux)

Début, fin, interruption

On l'on l'utilise le plus souvent pour la cellule du début, elle correspond à la fonction "setup" dans un programme Arduino.

Traitement/Opération interne

Sert à symboliser les actions internes qui ne font pas appel à des entrées ou des sorties. Par exemple Attendre x secondes sera symboliser par un rectangle dans un algorigramme.

Décision 

Toutes les boucles ainsi que de nombreuses structures sont basées sur cette cellule, c'est généralement une question, une comparaison.

Sous-programme

Servent à symboliser des portions de programmes telles que des fonctions auxquelles ont fait appel dans un programme.

La structure linéaire :

C'est une suite d'action, il n'y a pas grand chose à expliquer.

Les structures alternatives :

Un simple si... alors...

Traduction en langage Arduino :

if (X == HIGH)
{
  digitalWrite(led, HIGH);
  delay(500);
  digitalWrite(led, LOW);
  delay(500);
}

Une autre structure :

Il s'agit d'un si..., alors..., sinon.... Il permet d'exécuter une partie du programme si la condition est fausse.

Traduction en langage Arduino :

if (X == HIGH)
{
  digitalWrite(led, HIGH);
  delay(500);
  digitalWrite(led, LOW);
  delay(500);
}
else
{
  delay(500);
}

Les structures itératives ou répétitives :

La structure faire... jusqu'à...

Execute la suite d'action contenue dans la boucle puis si la condition est vérifiée, revient au début de la boucle.

Traduction en langage Arduino :

do {
     digitalWrite(led, HIGH);
     delay(500);
     digitalWrite(led, LOW);
     delay(500);
} while (X == HIGH);

La structure tant que... faire... :

Ressemble à la structure faire jusqu'à mais contrairement à celle-ci, si la condition n'est pas vérifiée alors la boucle ne s’exécutera pas.

Traduction en langage Arduino :

while (X == LOW)
{
 digitalWrite(led, HIGH);
 delay(500);
 digitalWrite(led, LOW);
 delay(500);
}

La structure Pour... Faire... :

C'est la seule structure dont ont connait le nombre d'exécutions, on définit un nombre de départ, un nombre que l'on doit atteindre ainsi qu'un pas.

Traduction en langage Arduino :

for(X = 5; X <= 0; X--) //(valeur initiale; valeur finale; pas)
{
  digitalWrite(led, HIGH);
  delay(500);
  digitalWrite(led, LOW);
  delay(500);
}

void setup() {

}

void loop () {

}

 
  // Librairies :

  // Pins E/S :

  // Variables :

void setup() {

  // Déclarations E/S :

  // Servomoteur(s) :

  // Ecran(s) LCD :
  
  // Connectique :

}

void loop() {
  
}

  // Pins E/S :
int led = 13;                        // On attribue led au pin 13
int button = 8;                      //On attribue boutton au pin 8

  //Fonction d'initialisation :
void setup() {
  // E/S :
pinMode(led, OUTPUT);                // On définit led comme une sortie
pinMode(button, INPUT);              // On définit bouton comme une entrée
}

// Boucle infinie :
void loop() {
  
while(digitalRead(button) == LOW)    // Boucle TANT QUE ... FAIRE
{
  digitalWrite(led, LOW);            // Mettre la sortie led à l'état BAS
  delay(100);                        // Attendre 100ms
}

digitalWrite(led, HIGH);             // Mettre la sortie led à l'état HAUT
delay(100);                          // Attendre 100ms
}

• Mauvaise configuration des ports

• Led mise dans le mauvais sens
• Les deux bornes de la led relié à du 5V

• Problème dans la programmation

• Tout autre erreur de câblage

• Les pins digital : Ce sont des entrées ou des sorties faites pour envoyer ou recevoir du 0 ou du 5V (niveau HAUT ou BAS)

• Les pins analogue: Idem que les pins digital mais peuvent envoyer ou détecter une tension entre 0 et 5V qu'il mettra sur une échelle de 0 à 1023. Par exemple pour envoyer du 5V il faut lui dire d'envoyer 1023.

•  
• Les pins de puissances: pour alimenter les différents composants (5V, 3V3, GND(mise à la masse))
•  

• PWM: http://www.micropik.com/PDF/SG90Servo.pdf
• PWM: https://fr.wikipedia.org/wiki/Modulation_de_largeur_d'impulsion