Introduction

Nous y voilà, je commence enfin ma série « Les objets connectés au service de ma conquête du monde ».

Plus sérieusement, cela fait maintenant un bout de temps que je vous présente des gadgets en tout genre, du Eye-tracker aux lampes connectées en passant par les plateformes de prototypage, etc. J’ai écrit quelques billets expliquant comment fonctionnent et comment utiliser ces objets de manière unitaire. Mon envie avec cette nouvelle série est de créer un projet mêlant toutes ces technologies afin d’aboutir à un produit complet.

Le sujet ne se prend pas au sérieux mais il devra tenir la route techniquement.

De manière plus personnelle, l’objectif de ce projet était de découvrir un peu plus l’électronique puisque mes connaissances s’arrêtent à mes cours de 4^ème. Aussi, je vous demanderais d’être tolérant quant à la qualité de mes explications sur le sujet. D’ailleurs, n’hésitez pas à me corriger.

Ceci étant dit, je vous présente donc le sujet : “Une tourelle de défense pilotée (véritablement) du bout des doigts.”

Voici donc une vidéo de ce que nous allons apprendre à fabriquer/programmer :

  Pour l’exercice j’ai acheté un Vortex Nitron à 50^€ sur Amazon qui est le premier fusil automatique de la gamme. Le pied aurait été de jouer avec le Vulcan qui possède une cartouchière et un trépied mais qui est aussi au prix de 220€. Donc restons raisonnable.

Pour la partie électronique j’ai utilisé une carte Arduino mais la NetDuino ou la Gadgeteer auraient tout aussi bien fait l’affaire. Les seuls composants dont vous aurez besoin sont des fils et un relais activable en 5V et qui laissera passer au moins du 9V.

Mécanique : Démontage et analyse du Nerf

Pour commencer je vous conseille très vivement de faire l’acquisition d’une visseuse. Pourquoi ? Parce que dévisser, revisser, dévisser, … les 30 vis qui protègent votre Nerf auront probablement raison de votre patience.

Récapitulons un peu le fonctionnement du fusil. La gâchette du bas actionne le moteur et celle du haut actionne le tir. L’objectif sera donc dans cette étape de laisser les 2 gâchettes actionnées et de bloquer ou débloquer l’alimentation de manière manuelle.

On commence donc par dévisser tout ça afin d’exposer les entrailles de la bête.

En cherchant bien on trouve 2 fils qui sortent du capot contenant les piles.

On en coupe un (pour moi c’était le marron).

L’étape suivante consiste à bloquer les 2 gâchettes en position « enclenchée ». On peut les bloquer ainsi car le moteur n’est plus alimenté à cause du fil coupé. Faites bien attention car les pièces et les ressorts ont tendance à ne pas tenir en place et à sauter.

Branchons ensuite un fil à chacune des extrémités du fil que nous avons coupé et relions-les à une planche de prototypage avec un bouton poussoir entre les deux.

Nous pouvons désormais tester que notre mini hack fonctionne en appuyant sur le bouton poussoir. Cela va normalement fermer le circuit et le fusil se mettra à tirer en rafale tant que vous appuierez sur le bouton.

Passons désormais à la partie électronique avec Arduino.

Arduino, relais et port série

Dans un premier temps, nous allons simplement remplacer le bouton que j’utilisais dans l’étape précédente par un programme Arduino.

Ce programme aura pour objectif d’activer un relais via une commande, relais qui activera donc le mode rafale du Nerf.

Un relais est un composant électronique qui permet de fermer ou ouvrir un circuit en ouvrant/coupant la communication entre 2 broches. L’activation du relais est effectuée en alimentant celui-ci sur 2 broches spécifiques. Au repos, le circuit est fermé entre A et B. Une fois le relais alimenté, la bobine se charge et attire la broche vers lui, fermant ainsi le circuit de A vers C.

Pour activer notre relais nous n’avons donc qu’à alimenter celui-ci sur les 2 broches D et E afin qu’il active la liaison entre les broches A et C.

Pour cela, nous utiliserons la communication via le port USB depuis une application console en C# afin d’envoyer nos commandes à notre carte Arduino, lui-même faisant l’activation du relais. Les commandes seront simplistes puisqu’il s’agira de 0 : Off ou 1 : On.

Rappelez-vous, dans cet article, je vous montrais comment allumer une LED avec quelques lignes de code dans Visual Studio. Nous n’aurons pas beaucoup plus à faire puisqu’il suffit de remplacer la PIN 13 de l’exemple par la PIN sur laquelle nous avons branché un des fils relié à la broche D ou E. Voici donc le code actionnant notre relais en simultané avec l’allumage de la lampe :

int ledPin = 13;
int relayPin = 8;

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

void loop()
{
    digitalWrite(ledPin, HIGH);   // set the LED on
    digitalWrite(relayPin, HIGH);   // set the Relay on
    delay(1000);                  // wait for a second
    digitalWrite(ledPin, LOW);    // set the LED off
    digitalWrite(relayPin, LOW);   // set the Relay off
    delay(1000);                  // wait for a second
}

« Oui, mais comment fait-on pour lui parler à notre Arduino ? »

C# et Communication USB

Le Framework .NET nous simplifie grandement les choses puisqu’il met à notre disposition la classe System.IO.Ports.SerialPort, classe qui expose la méthode statique GetPortNames() qui nous permettra de récupérer la liste des ports série disponibles.

Nous allons donc créer une application console dans laquelle nous créerons la méthode suivante servant à récupérer la liste des ports disponibles et à en sélectionner le premier.

public static string GeFirstAvailableSerialPort()
{
    return System.IO.Ports.SerialPort.GetPortNames().FirstOrDefault();
}

Une fois le nom du port disponible récupéré, nous allons instancier la classe SerialPort en utilisant le constructeur prenant en paramètre le nom du port :

SerialPort mySerialPort = new SerialPort(firstPort);

Nous configurons ensuite le mode de communication avec l’Arduino :

mySerialPort.BaudRate = 9600;
mySerialPort.Parity = Parity.None;
mySerialPort.StopBits = StopBits.One;
mySerialPort.DataBits = 8;
mySerialPort.Handshake = Handshake.None;

Si nous voulons récupérer les données entrantes via ce port, nous pouvons nous abonner à l’évènement DataReceived de la classe SerialPort :

mySerialPort.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

Enfin, nous ouvrons le port :

mySerialPort.Open();

Désormais, nous sommes à l’écoute des communications entrantes depuis l’Arduino. Pour envoyer nous-même des données à la carte il faut utiliser la méthode Write.

Le code final permettant de notifier la carte qu’elle doit actionner ou désactiver le relais est le suivant :

class Program
    {
        static void Main(string[] args)
        {
            var firstPort = GeFirstAvailableSerialPort();
            if (firstPort != null)
            {
                SerialPort mySerialPort = new SerialPort(firstPort);

                mySerialPort.BaudRate = 9600;
                mySerialPort.Parity = Parity.None;
                mySerialPort.StopBits = StopBits.One;
                mySerialPort.DataBits = 8;
                mySerialPort.Handshake = Handshake.None;

                mySerialPort.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

                mySerialPort.Open();

                // Shutdown the rifle
                mySerialPort.Write("0");

                Console.WriteLine("Press 1 to activate the rifle, 0 to desactivate and ESCAPE to quit...");
                Console.WriteLine();
                var quit = false;
                while (!quit)
                {
                    ConsoleKeyInfo key = Console.ReadKey();
                    switch (key.Key)
                    {
                        case ConsoleKey.Escape:
                            quit = true;
                            break;
                        case ConsoleKey.D0:
                            mySerialPort.Write("0");
                            break;
                        case ConsoleKey.D1:
                            mySerialPort.Write("1");
                            break;
                    }
                }
                mySerialPort.Close();
            }
        }

        private static void DataReceivedHandler(
                            object sender,
                            SerialDataReceivedEventArgs e)
        {
            var sp = (SerialPort)sender;
            string data = sp.ReadExisting();
            Console.WriteLine();
            Console.WriteLine("Data Received:" + data);
        }

        public static string GeFirstAvailableSerialPort()
        {
            return System.IO.Ports.SerialPort.GetPortNames().FirstOrDefault();
        }
    }

Nous allons maintenant modifier notre code Arduino afin qu’il prenne en compte les messages envoyés via le port USB.

Pour cela, dans la méthode de Setup, nous allons ouvrir la communication sur le port série en indiquant le baudrate (vitesse de transmission) de 9600.

void setup() {
    pinMode(relayPin, OUTPUT);
    // Turn the Serial Protocol ON
    Serial.begin(9600);
}

Ensuite, dans la boucle loop, nous devons vérifier si des données sont disponibles sur le port série :

if (Serial.available() > 0)

Si tel est le cas, alors nous lisons les octets reçus.

byteRead = Serial.read();

Maintenant que nous savons comment communiquer via USB, finalisons notre code afin qu’il actionne le relais. Dans le code ci-dessous il faut noter que 49 correspond au code hexadécimal du chiffre 1.

int relayPin = 8;
byte byteRead ;

void setup() {
    pinMode(relayPin, OUTPUT);
    // Turn the Serial Protocol ON
    Serial.begin(9600);
}

void loop() {
    /*  check if data has been sent from the computer: */
    if (Serial.available() > 0)
    {
        byteRead  = Serial.read();
                Serial.write(byteRead);
        if (byteRead==49)
        {
            digitalWrite(relayPin, HIGH);   // set the rifle on
        }
        else
        {
            digitalWrite(relayPin, LOW);   // set the rifle off
        }
    }
}

Voila, nous en avons fini pour cette première partie.

Dans la prochaine partie nous allons découvrir comment utiliser la Force pour contrôler notre Arduino.

A bientôt.