L’accès à certaines fonctionnalités embarqués sur un avion de combat (navigation, systèmes d’armes, désignateur, …) passe par un écran multifonctions (MultiFunction Display). Bien que certains simulateurs proposent un cockpit cliquable, il est toujours embêtant de devoir orienter le champ de vision à chaque fois que l’on souhaite effectuer une action. Du coup, l’utilisation d’un périphérique matériel augmente l’immersion et améliore l’expérience de jeu.

Les solutions commerciales existantes (ThrustMaster Cougar Pack) ne m’ayant pas impressionné, j’ai décidé de concevoir un écran multifonction fonctionnant sur USB.

Le projet que je présente est conçu pour fonctionner avec DCS. Cependant, comme il utilise un écran HDMI et des contrôles type joystick, il n’y a pas de raisons pour que ça ne marche pas avec d’autres simulateurs.

Principes de fonctionnement

L’idée consiste à configurer DCS pour envoyer l’image des MFD gauche et droite sur deux écrans supplémentaires. Pour ce faire, il faut créer un fichier de configuration dans le dossier MonitorSetup du jeu et ajouter ces deux paramètres (il faut bien évidemment ajuster les offsets pour tomber dans les bons écrans) :

_  = function(p) return p; end;
name = _('MFD_Display');
Description = 'Config maison'
Viewports =
{
     Center =
     {
          x = 1920;
          y = 0;
          width  = 1920;
          height = 1080;
          viewDx = 0;
          viewDy = 0;
          aspect = 1.6;
     }
}

LEFT_MFCD =
{
    x = 1920*2+(1024/2-768/2);
    y = 0;
    width  = 768;
    height = 768;
}

RIGHT_MFCD =
{
    x = 1920*2+1024+(1024/2-768/2);
    y = 0;
    width  = 768;
    height = 768;
}

UIMainView = Viewports.Center
GU_MAIN_VIEWPORT = Viewports.Center

L’assignation des touches se fait simplement dans DCS, comme n’importe quel autre périphérique d’entrée.

Pour l’affichage, j’ai choisi un écran LCD 4:3 de 8 pouces. Il a une résolution de 1024×768 :

​​

Son prix et sa taille en font une solution intéressante : https://fr.aliexpress.com/item/32325920866.html?spm=a2g0s.9042311.0.0.d0dd6c37EdzyS4​

L’électronique

Conception

Pour simplifier l’intégration matérielle, j’ai choisi d’utiliser un petit microcontrôleur de chez Microchip capable de faire de l’USB et de l’I2C : le PIC18F25K50. Il communique avec 4 cartes filles qui s’occupent chacune de 7 boutons.

La séparation en plusieurs cartes répond à deux impératifs :

1. Rentrer dans une conception Autodesk EAGLE version gratuite
2. Diminuer les coûts de fabrication en réduisant la surface de circuit imprimé

La carte mère sera montée au dos du MFD :

Deux cartes en angle et deux cartes droites permettent de former un cadre autour de l’écran LCD :

​ ​

La carte mère

La carte mère du MFD se contente de faire le lien entre les différentes cartes filles (I2C) et le PC (USB). Le schéma est donc des plus simples, il reprend celui de la boite à boutons ou de l’interface HID, mais avec un composant différent :

​On retrouve une horloge, un circuit de reset, le connecteur USB, un connecteur pour l’I2C et un connecteur de programmation. Pour changer mes habitudes, j’ai réalisé mes cartes avec des composants à montage en surface (CMS) :

Les cartes filles

Bien que 2 formes différentes soient nécessaires, elles ont toutes le même schéma (à la différence de l’adresse). Il s’agit d’un multiplexeur 8 entrées tout ou rien vers I2C MCP23008. Les résistances de tirages sont intégrées dans la puce. Les cartes sont adressées par un pont à souder pour le bit de poids faible et câblé en dur à 1 pour les cartes en L (0 pour les cartes en I).

Deux connecteurs I2C permettent de former une chaine avec les 4 cartes. Un troisième permet de relier la carte mère sur l’une des cartes filles.

La configuration des boutons à bascules présents aux 4 coins du MFD oblige à avoir deux formes de cartes:

​

​

Les dimensions sont adaptées à la taille de l’écran de 8 pouces et au boitier imprimé en 3D dessiné tout spécialement.

Réalisation

J’ai sous-traité la fabrication des PCB (double couches) à NextPCB.

Les soudures des composants CMS sont réalisées au fer à souder, avec une panne fine. Pour rendre cela possible, j’ai choisi des boitiers SOIC (gros composants CMS, pas de 1.27mm) et des formats 0805 pour les résistances et condensateurs. Finalement, le composant le plus petit et le plus difficile à souder est la LED indiquant la mise sous tension.

NB : une bonne pince brucelles est nécessaire !

Intégration mécanique

J’ai fait découper au LASER des tôles d’inox pour réaliser les faces avant (https://www.metal-laser.com/). Le boitier plastique qui accueille ​les cartes filles ainsi que les différentes touches sont imprimés en 3D. La conception mécanique et l’intégration des cartes électroniques a été réalisée à l’aide Fusion 360. Cet outil permet de facilement faire converger les CAO électroniques et mécaniques.

Il est important de pouvoir vérifier la profondeur du boitier plastique, notamment pour que les boutons poussoirs tombent en dessous des touches plastiques.
​

L’écran LCD est fixé (scotché ou collé) à l’arrière du cadre. La face avant est également collée au boitier plastique.

Le logiciel

Une fois n’est pas coutume, le code du microcontrôleur a été écrit en C à l’aide de MikroC. Outre l’initialisation de la puce et le driver des multiplexeurs, la boucle principale se contente de lire les 4 ports d’entré sur l’I2C et d’envoyer le rapport USB HID.

/**
* Version IO Expander MCP23018
**/

#include "MCP23008.h"

#define USB_BUFFER_LEN       4
#define NB_MCP               4

unsigned char readbuff[USB_BUFFER_LEN] absolute 0x500;
unsigned char writebuff[USB_BUFFER_LEN] absolute 0x540;

int reset_mcp23017 = 1;

void interrupt() {
    USB_Interrupt_Proc();        // USB servicing is done inside the interrupt
    USBIF_bit = 0;
}

// define callback function
void I2C1_TimeoutCallback(char errorCode) {
   if (errorCode == _I2C_TIMEOUT_RD) {
     //LED0 = 1;
     // do something if timeout is caused during read
   }

   if (errorCode == _I2C_TIMEOUT_WR) {
     //LED1 = 1;
     // do something if timeout is caused during write
   }

   if (errorCode == _I2C_TIMEOUT_START) {
     //LED0 = 1;
     // do something if timeout is caused during start
   }

   if (errorCode == _I2C_TIMEOUT_REPEATED_START) {
     //LED1 = 1;
     // do something if timeout is caused during repeated start
   }
   
   reset_mcp23017 = 1;
}
          
void main() {
    int i = 0;
    int cpt = 0;
    
    uint16_t temp;

    ANSELA = 0;
    ANSELB = 0;
    ANSELC = 0;
    SLRCON = 0;

    ADCON1 |= 0x0F;                         // Configure all ports with analog function as digital
    CM1CON0 |= 7;                           // Disable comparators

    TRISB = 0xff;
    TRISB.f2 = 0;
    LATB.f2 = 1;

    I2C1_Init(400000);         // initialize I2C communication
    
    // set timeout period and callback function
    I2C1_SetTimeoutCallback(40000, I2C1_TimeoutCallback);

    reset_mcp23017 = 1;

    FSEN_bit = 1;
    UPUEN_bit = 1;
    HID_Enable(&readbuff,&writebuff);
    
    // Enable USB device interrupt
    IPEN_bit = 1;
    USBIP_bit = 1;
    USBIE_bit = 1;
    GIEH_bit = 1;

    while (1) {
        if (reset_mcp23017) {
           LATB.f2 = 0;       //RESET MCP23017
           Delay_ms(250);
           LATB.f2 = 1;
           Delay_ms(250);

           for (i=0; i<NB_MCP; i++) {
            MCPreset(i);
            Delay_ms(5);
           }
          reset_mcp23017 = 0;
        }

        memset(writebuff, 0x00, USB_BUFFER_LEN);
    
        for (i=0; i<NB_MCP; i++) {
          temp = MCPread(i, GPIO);
          writebuff[i] = ~temp;
          Delay_ms(5);
          if(reset_mcp23017) break;
        }
        
        HID_Write(writebuff, USB_BUFFER_LEN);
        Delay_ms(5);
    }
}

Le premier test

Un dock USB 3.1 peut servir pour gérer le HDMI et l’USB simultanément, ce qui permet d’avoir une unique prise USB occupée sur le PC. Si la configuration de DCS est correcte et que l’écran est bien détecté, voici le résultat que l’on peut obtenir :

La même chose en vidéo :

Conclusion

Il me reste encore à imprimer des touches propres et à finir l’état de surface de la face avant. Pour le reste, le rendu est vraiment sympa. Reste à tester réellement sur une session de pilotage plus longue.

Le retour de l’interface USB HID !

Introduction

Quand les potes disent vouloir jouer à DCS World en multijoueurs, l’électronicien qui sommeil en moi se dit « Il me faut plus de boutons ! ». En effet, les périphériques de jeux habituels sont relativement peu pourvus en boutons, et démarrer un avion de chasse est un peu plus complexe que démarrer une Twingo. L’idée a donc germée de concevoir une électronique vue comme un joystick et proposant des entrées tout ou rien et/ou analogiques. Il est ainsi possible de réaliser son tableau de bord, avec de vrais boutons, des étiquettes… Bref, on s’y croirait.

Conception de la carte

Spécifications

Comme on ne change pas une équipe qui gagne, je suis reparti de ma première version de l’interface USB HID. Voici quelques éléments en vrac:

• Alimentation par le bus USB
• MCU : PIC18F4550 cadencé à 48MHz par un quartz 24MHz
• Carte compacte
• pas de composants additionnels à prévoir pour les entrées tout ou rien
• 16 entrées ToR
• 8 entrées analogiques 10 bits

Il me fallait écouler un vieux stock de PIC18F4550 en format DIP40, donc le CMS sera pour une prochaine réalisation. Les entrées se font sur des borniers à vis au pas de 2.54mm. Les résistances de pull-up internes au PIC permettent d’exploiter directement les ports B et D en tout ou rien. Le port A est utilisé en entrées analogiques.

Schéma et PCB

Le schéma de la carte ne constitue en rien une révolution. On retrouve presque à l’identique celui de ma première interface.

L’implantation est par contre beaucoup plus compacte.

Réalisation

Pour une fois, j’ai décidé de sous traiter la fabrication des circuits (au-delà d’un exemplaire, la gravure à la fraiseuse n’est pas franchement efficace). J’ai donc envoyé tout ça chez les chinois (NextPCB pour ne pas les citer). Le résultat est impeccable, pour un prix de revient d’1.60€/pièce, port compris :

Seul petit bémol : la durée de livraison pour l’expédition économique : compter plusieurs semaines. Place à la soudure !

Programmation

Là encore, rien de révolutionnaire : le code est écrit en C avec MikroC for PIC. Les PIC sont ensuite flashés en série grâce à un PicKit et MPLAB IPE.

Le descripteur HID déclare donc 16 entrées switch et 8 axes analogiques:

hid_rpt_desc =
  {
    0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
    0x15, 0x00,                    // LOGICAL_MINIMUM (0)
    0x09, 0x04,                    // USAGE (Joystick)
    0xa1, 0x01,                    // COLLECTION (Application)
    0x05, 0x02,                    //   USAGE_PAGE (Simulation Controls)
    0x09, 0xbb,                    //   USAGE (Throttle)
    0x09, 0xc5,                    //   USAGE (Brake)
    0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
    0x26, 0xff, 0x00,              //   LOGICAL_MAXIMUM (255)
    0x75, 0x08,                    //   REPORT_SIZE (8)
    0x95, 0x02,                    //   REPORT_COUNT (2)
    0x81, 0x02,                    //   INPUT (Data,Var,Abs)
    0x05, 0x01,                    //   USAGE_PAGE (Generic Desktop)
    0x09, 0x01,                    //   USAGE (Pointer)
    0xa1, 0x00,                    //   COLLECTION (Physical)
    0x09, 0x30,                    //     USAGE (X)
    0x09, 0x31,                    //     USAGE (Y)
    0x09, 0x32,                    //     USAGE (Z)
    0x09, 0x33,                    //     USAGE (Rx)
    0x09, 0x34,                    //     USAGE (Ry)
    0x09, 0x35,                    //     USAGE (Rz)
    0x95, 0x06,                    //     REPORT_COUNT (6)
    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
    0xc0,                          //   END_COLLECTION
    0x05, 0x09,                    //   USAGE_PAGE (Button)
    0x19, 0x01,                    //   USAGE_MINIMUM (Button 1)
    0x29, 0x10,                    //   USAGE_MAXIMUM (Button 16)
    0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
    0x25, 0x01,                    //   LOGICAL_MAXIMUM (1)
    0x75, 0x01,                    //   REPORT_SIZE (1)
    0x95, 0x10,                    //   REPORT_COUNT (16)
    0x55, 0x00,                    //   UNIT_EXPONENT (0)
    0x65, 0x00,                    //   UNIT (None)
    0x81, 0x02,                    //   INPUT (Data,Var,Abs)
    0xc0                           // END_COLLECTION
  };

Le rapport USB associé est le suivant:

Utilisation

Le câblage des entrées analogiques peut exploiter l’alimentation de la carte (5V sur USB) pour utiliser des potentiomètres:

Le câblage des boutons se fait entre la broche d’entrée et la masse. La résistance de pull-up interne s’occupe de polariser l’entrée quand le bouton est ouvert.

Une fois le tout branché et l’USB relié au PC, Windows devrait voir un nouveau périphérique de jeu:

Conclusion

Il ne reste qu’à faire la mécanique !

Si vous aussi êtes fan de Mass Effect et avez investi dans l’édition collector de Mass Effect Andromeda, vous vous retrouvez sans doute avec un Nomad ND1 télécommandé par smartphone. Comme l’application Android est toute nulle perfectible et peu stable, il parait intéressant de piloter ce petit drone roulant à partir d’un PC ou, pourquoi pas, d’une radio commande conventionnelle.

Pour ce faire, je vais décortiquer la communication mise en place entre le Nomad et le smart phone.

Deux types de communication

Le Nomad est télécommandé (vitesse, direction, allumage des feux) mais dispose également d’une caméra afin de fournir un retour vidéo temps réel. Du coup, deux communications différentes sont utilisées.

Connexion WiFi

Tout d’abord, il est bon de préciser que la communication radio entre le smartphone et le Nomad est basée sur une liaison WiFi 2.4GHz. Le Nomad est un point d’accès avec serveur DHCP. Quand on connecte un périphérique réseau sur le Nomad, on obtient automatiquement une adresse IP.

Le Nomad sera toujours accessible à l’adresse 192.168.0.1.

Retour Vidéo

Je commence par exposer le fonctionnement du retour vidéo puisqu’il s’agit du moins complexe et qu’il peut être solutionné avec des logiciels comme VLC.

Le Nomad se comporte comme une caméra IP. Il héberge un serveur de streaming RTSP. Le point d’accès vidéo est vs1. Il est donc possible d’ouvrir le flux vidéo en accédant à l’adresse:

rtsp://192.168.0.1/vs1

Télécommande

L’envoie des commandes au Nomad est un peu plus artisanal. En effet, la messagerie entre le smartphone et le Nomad exploite une communication UDP sans protocole standard particulier. Les informations qui vont suivre sont issues de mes observations et d’analyses réseaux faites avec WireShark. N’ayant qu’un seul Nomad sous la main, il est possible que le comportement décrit ne soit pas identique pour tous les modèles.

Première connexion

La communication UDP bidirectionnelle s’établit sur le port 8234. Comme l’UDP n’est pas un protocole en mode connecté, il est nécessaire de pouvoir vérifier la présence d’un interlocuteur de l’autre côté de la liaison. Pour ce faire, le Nomad propose une commande de ping.

Il est possible d’envoyer la chaine MAKO_CONNECT et le Nomad répond CONNECT_OK.

On notera au passage l’amalgame entre le mako et le nomade qui laisse supposé l’existence d’un mako radiocommandé?

Récupération du statut

Il est possible de récupérer l’état général du Nomad (niveau de batterie et allumage des feux). Pour ce faire, il faut envoyer la chaine MAKO_READ_BATT. Le Nomad va alors répondre trois lignes:

BATT=%d
LED1=%b
LED2=%b

On obtient le niveau de batterie entre 0 et 100%, ainsi que l’état des deux groupes de feux avant (0=éteint, 1=allumé)

Allumage des feux

Pour gérer les feux avant du Nomad, il y a les commande MAKO_LED%d_ON et MAKO_LED%d_OFF. Il est nécessaire de préciser dans la commande le numéro des feux à allumer ou éteindre (par exemple MAKO_LED1_ON ou MAKO_LED2_OFF). Le Nomad ne répond pas à ces commandes. Le statut des LED peut être récupérer par la commande précédente MAKO_READ_BATT.

Envoie des consignes

L’envoie des consignes est un peu plus problématique. En effet, une seule commande binaire est utilisée pour envoyer les consignes de vitesse avant, de vitesse arrière et de direction. En outre, la commande semble contenir un numéro unique qui, s’il est mal renseigné, bloque l’interprétation de la commande complète.

Voici la structure de la trame binaire envoyée. Les valeurs sont données en hexadécimal:

Les consignes de vitesse  sont données en 0-255, soit en marche avant, soit en marche arrière.

La consignes de direction est également en 0-255, avec la valeur 128 pour aller tout droit. 0 tourne à gauche, 255 tourne à droite.

La réponse du Nomad à cette commande est assez impénétrable:

On y retrouve le même code qu’à la commande. Ensuite, il y a deux octets à 0, deux octets qui sembles avoir une valeur proche de 0x66, les recopies des deux consignes de vitesse et encore deux octets à 0.

Conclusion

Même s’il reste quelques octets inexpliqués dans les trames d’envoie de consigne et de réponse, il est tout à fait possible de piloter le Nomad depuis n’importe quel périphérique WiFi. Voici d’ailleurs un driver LabVIEW permettant le pilotage du Nomad:

NomadND1_LV2019.zip

En outre, j’envisage le développement d’une interface Radio <-> WiFi à base d’ESP32. L’idée est de récupérer les signaux d’écolage radio, voir les PWM de pilotage servo issues d’un récepteurs modélisme et de générer les trames UDP « qui vont bien » afin de piloter le Nomad comme il se doit!

Si une âme charitable et possédant un Nomad peut tester le pilotage par UDP afin de s’assurer que la trame C0A8 0101 0000 0421 XXXX XX fonctionne sans modifications, le retour d’expérience sera intéressant pour compléter cette petite introduction au pilotage du Nomad 🙂

Les bruiteurs pour avion de modélisme disponibles dans le commerce sont relativement chers (150€ pour ce modèle de MotionRC). Aujourd’hui, avec les modules disponibles pour la bricole autour des arduinos, il doit être possible de fabriquer un bruiteur à moindre frais. C’est ce que je vais essayer de faire dans cette article.

Le matériel

Pour construire mon bruiteur, j’ai choisi de partir sur un arduino nano (ou sa copie chinoise) et un module lecteur MP3-TF-16P.

Le matériel le plus chers sera donc la carte SD pour stocker les fichiers sons.

L’arduino nano sera utilisé pour acquérir le signal PPM de pilotage moteur et envoyer les informations de lecture fichiers au module MP3 via l’UART.

Le module MP3-TF-16P est un codec audio associé à un amplificateur capable de décoder des fichiers MP3 et WAV et de les jouer sur un haut parleur de 3W.

Principe de fonctionnement

Le signal PPM issu du récepteur radio de l’avion est un pulse de 1 à 2ms émis toutes les 22ms ou 11ms (DSMX). Pour plus de détail, rendez-vous sur la page Récepteur radio-modélisme sur USB. L’arduino doit donc mesurer la durée de l’état haut du pulse. Cela tombe bien, une fonction native s’en occupe: pulseIn(). Elle renvoie la durée des pulses reçus sur une broche d’entrée en µs.

La plage de 1000µs à 2000µs est découpée en 6 plages réparties comme suis:

1000 — OFF— 1100 — RPM1 — 1280 — RPM2 — 1460 — RPM3 —1640 — RPM4 — 1820 — RPM5 — 2000

Chaque plage est associée à un fichier son sur la carte SD. Exception faite de la plage MotorOff qui donne lieu à la lecteur d’un fichier de démarrage moteur et d’une fichier d’arrêt moteur quand la consigne sort ou entre dans la plage.

Les fichiers sons sont téléchargeables sur le site Simviation par exemple.

Câblage

Le câblage du système est très simple:

1. Récupérer une prise servo 3 points
2. Alimenter l’arduino entre noir et rouge (5V issu du BEC du récepteur)
3. Alimenter le module MP3-TF-16P avec le même 5V (pin 1 : Vcc, pin 7 et pin 10 : Gnd)
4. Connecter le signal (fil orange) sur une entrée de l’arduino (j’utilise D2)
5. Connecter l’UART du module MP3-TF-16P (pin 2 : Rx, pin 3 : Tx) sur les broches Rx et Tx de l’arduino (pensez bien à croiser Rx->Tx et Tx->Rx)
6. Connecter le haut parleur sur le module MP3-TF-16P (pin 8 : Spk- et pin 6 : Spk+)

C’est tout!

[EDIT] Voici un schéma de la version amplifiée:

La spécification du module MP3-TF-16P est disponible ici.

Programmation de l’arduino

Le programme de l’arduino est assez simple. Il est basé sur une machine à états qui gère les différents régimes moteurs et les transitions de l’un à l’autre.

Le code source de l’arduino est disponible ici. La version que je propose utilise 7 fichiers son au total. Pour des raisons de simplicité d’intégration je n’ai pas utilisé la bibliothèque DFPlayer-Mini, préférant écrire ma propre implémentation. En effet, le protocole de communication mise en place sur le MP3-TF-16P est relativement simple. Il est très bien décrit dans la spécification du module:

Le même format de trame est utilisée en réception et en émission.

La carte SD

Les fichier sons doivent être rangés et nommés d’une certaine manière pour que le module puisse les lire. Voici l’arborescence que j’utilise:

• 01
  • 001.wav
  • 002.wav
  • 003.wav
  • 004.wav
  • 005.wav
  • 006.wav
  • 007.wav

Les fichier 001 et 007 sont les fichier startup et shutdown. Les fichiers 002 à 006 sont les régimes moteurs établis.

[EDIT] Ajout d’un amplificateur et utilisation d’un haut parleur vibrant (exciter)

Comme prévu, les haut parleurs de 3W ne donne pas satisfaction dans un avion RC: il faudrait percer le fuselage pour sortir le son. Un solution proposée entre autre par MotionRC est d’utiliser des excitateur vibrants. Ils fonctionnent comme un haut-parleur électroacoustique, mais sans membrane. Au lieux de la membrane, il y a juste un adhésif double faces collé sur la bobine. En montant ce type de matériel sur un avion, tout le fuselage devient haut-parleur!

Le modèle que j’ai retenu est un Dayton Audio DAEX25FHE-4 de 24W. Je l’ai couplé à un amplificateur TPA3110 sur carte de développement :

J’ai récupéré l’une des deux sorties DAC_L ou DAC_R du module MP3-TF-16P pour attaquer l’ampli. J’alimente ce dernier avec une batterie 2S auxiliaire afin de ne pas endommager le circuit électrique principal de mon avion en cas de défaillance.

Voici le résultat en images (et surtout en musique…):

Conclusion

Voici donc un petit bruiteur sans prétentions qui semble donner des résultats satisfaisants pour un budget contenu. Je n’ai pas encore pu essayer avec un haut parleur de 3W, mais une chose est sûre: avec mon petit haut parleur de 0.1W, on n’entend pas le bruiteur à cause du bruit de l’hélice de l’avion. Dans le pire des cas, j’ajouterais un amplificateur de 3W additionnel sur la sortie non amplifiée du module pour mettre deux HP en stéréo sur l’avion.

J’envisage d’équiper un su29mm de chez ParkZone.

Avant de commercer cet article, je tiens à remercier Amaury qui m’a permis de publier cet article sur son site. 🙂

Je découvre actuellement l’électronique et la programmation entre  LabVIEW et Arduino et je tiens à partager certains résultats avec vous. Certaines notions abordées ne seront pas forcément poussées ou assez détaillées pour des lectures ou lectrices plus expérimenté(e)s.

Théorie de mesure de distance Lidar

Lidar est l’acronyme anglais de light detection and ranging qui est une technique qui permet de mesurer des distances allant de quelques centimètres à la distance Terre-Lune. Le lidar Garmin utilisé ici, génère un train d’onde électromagnétique cohérente (un faisceau laser InfraRouge) de longueur d’onde λ de 905 nm. Les trains d’onde sont envoyés à une fréquence comprise entre 10 à 20 kHz (à ne pas confondre avec la fréquence propre de l’onde du laser IR) d’après les datasheet. Les trains d’ondes se réfléchissent sur la cible visée par le capteur. Une partie de la lumière du laser revient sur le capteur. Une photodiode placée dans le Lidar et sensible dans la plage de longueur d’onde des IR reçoit l’onde réfléchie. L’écart de temps entre le départ d’un train d’onde et son retour est mesuré par le capteur. Cet écart de temps est proportionnel à la distance parcourue par l’onde. Cette technologie de mesure est communément appelée Time of Flight.

Le matériel utilisé pour la réalisation

Nota : un clavier et une souris seront très certainement nécessaires pour naviguer sur LattePanda.

Le Montage global

Le schéma suivant a été réalisé sur le logiciel libre Fritzing. N’ayant pas trouvé de modèle de LattePanda dans la librairie Fritzing, il a donc été représenté par sa carte Arduino qu’il intègre. Un schéma du LattePanda est donné après.

Figure 1 Schéma Global de la mesure Lidar (à l’aide du logiciel gratuit Fritzing)

L’intégration des différents éléments a été faite à l’aide d’un vieux jeu mécanos.

LattePanda

Le modèle de  LattePanda utilisé est le 4 GB/64 GB sous Windows 10. Ce modèle suffit pour faire tourner un LabVIEW 2014 (https://www.gotronic.fr/art-carte-lattepanda-4-gb-64-gb-dfr0419-24792.htm ). LattePanda sera très utile car il intègre une carte Arduino Leonardo et ses E/S associées. A l’aide des entrées et sorties numériques (0-5V), il sera possible de piloter le moteur pas à pas, le laser et d’acquérir le signal du Lidar. Le LattePanda est enfaîte un petit ordinateur d’instrumentation très compacte et assez puissant. Le projet n’utilise ici qu’une petite partie de sa capacité. Pour plus de détails sur LattePanda, le lecteur pourra se référer à l’article : LattePanda – Première mise en route

Le schéma ci-dessous reprend les principales E/S :

Figure 2 E/S LattePanda 4GB/64GB (https://www.lattepanda.com)

Le moteur Pas à Pas

Le moteur Pas à Pas bipolaire est contrôlé par un Driver Pololu (A4988). Le schéma ci-après (d’après le site Pololu qui commercialise le Driver) permet de connecter le moteur et le Driver. La puce du Driver est alimentée en 5 V par la carte Arduino du LattePanda. Ce driver a été choisi car il est facilement pilotable à partir des E/S digitales du Arduino, qui seront contrôlées par le logiciel ; lequel qui sera abordé après.

Figure 3 Schéma de fonctionnement du Drive couplé au moteur Pas à Pas (bipolaire)

Pour connecter correctement le moteur pas à pas au driver on pourra suivre le tableau suivant :

Figure 4 Schéma du moteur Pas à Pas (14HM11-0404S) d’après datasheet Go Tronic

Il est conseillé de relier la masse de l’alimentation du moteur à la masse du circuit afin d’éviter de le moteur ne grésille. Un petit régulateur LM7815 (15 V) permet de limiter la tension en entrée. Pour ma part j’ai utilisé deux piles de 9 V. En sortie du régulateur il vaut mieux ne pas oublier de limiter le courant à l’aide d’une résistance de charge. Le moteur consomme 400 mA par phase. Pour limiter le courant j’ai choisi de mettre en parallèle 4 résistances de 2 kΩ de 1/4 W qui forment une résistance 500 Ω supportant 1 W. Avec ce montage, le moteur ne chauffe et a assez de puissance pour réaliser ses pas. Un potentiomètre présent sur le driver permet de réguler la tension. Le réglage du courant limite est disponible dans la vidéo disponible en suivant de lien (https://www.youtube.com/watch?v=89BHS9hfSUk). Pololu préconise de régler le courant limite à l’aide du réglage du VREF et non en entrée comme cela a été fait ici.

• Une fois le montage du moteur réalisé, un test du moteur peut être réalise. Pour cela, la Pin STEP du driver peut être connecté au 5V délivré par l’Arduino. Le moteur est censé faire un pas. Sinon, revérifier le schéma de montage.

Les entrées MS1, MS2 et MS3 permettent de réduire le Pas, c’est-à-dire de gagner en précision angulaire. Le tableau ci-dessous affiche les niveaux à utiliser sur les pins en fonctions de la résolution du pas.

Figure 5 Tableau de résolution des pas d’après le site Pololu

Dans le cas présent, un pas complet est de 0,9°, un demi-pas en vaudra la moitié et ainsi de suite. Dans le présent projet, il n’est pas possible de descendre en dessous du demi-pas.

Nota important: il est fortement déconseillé de déconnecter le moteur du driver quand le moteur est en fonctionnement car le Driver peut-être endommagé. Il faudra couper l’alimentation du moteur pour effectuer des changements de postions (si besoin) sur les 4 fils du moteur pas à pas.

Le Lidar

Pour fonctionner le Lidar doit être alimenté en 5 V. L’alimentation 5 V de l’Arduino du LattePanda convient parfaitement. L’acquisition de la mesure de distance est lue en largeur d’impulsion (PWM) sur le fil jaune. Les datasheet préconisent l’utilisation d’une résistance de 1KΩ qui est reliée entre le fil de sortie de la mesure et la masse comme ci-dessous :

Figure 6 Schéma de câblage du lidar en acquisition de mesure en PWM (d’après datasheet Gramin)

Concernant les aspects métrologiques du capteur, la portée maximale du Lidar est de 40 mètres. Sa résolution est de 1 cm.

L’incertitude de mesure du Lidar Lite V3,  entre 0 et 5m est de ± 2.5cm et ± 10 cm au delà.

En sortie de mesure en largeur d’impulsion, la sensibilité est de 10 µs/cm. Cette valeur est à retenir pour comprendre la partie acquisition du signal du logiciel.

Le Laser de visée

Le laser est utile ici afin d’avoir un repère visuel sur l’orientation du Lidar. Le laser est du même type qu’utilisé pour les pointeurs laser de présentation (diode laser). Dans le cas présent, un laser d’alignement de 1 mW (λ = 650 nm) de couleur rouge a été utilisé. Il est alimenté en 5V par une entrée digitale de carte Arduino activable à partir du logiciel.

Attention aux yeux ! Le laser concentre l’énergie sur une surface très petite et a pour conséquence d’être nocif pour l’œil.

L’utilisateur est responsable de sa sécurité mais également celle des personnes autour !

Le logiciel/programme

Pour piloter les instruments (Lidar, moteur, laser) le logiciel LabVIEW 2014 est utilisé. Le but n’est pas de faire la présentation ni la promotion de ce logiciel mais de tenter d’expliquer comment utiliser certaines briques LINX. Si LabVIEW n’est pas utilisé, il sera quand même possible de piloter les instruments via un programme développé sur l’IDE Arduino. La suite de l’article pourra paraître obscure pour les personnes non initiées à LabVIEW; je m’en excuse par avance. Cependant, un petit effort a été fait pour que le code soit compris des personnes non initiées à LabVIEW.

Des briques (ou VI) de code LabVIEW ont été développées afin de faciliter grandement la compatibilité entre des cartes Arduino et LabVIEW. Pour utiliser les briques de codes LINX, la bibliothèque LINX côté LabVIEW doit avoir été installée préalablement dans VI Pack Manager (logiciel qui permet de charger des ToolKit ou librairies de programme).

Chargement des librairies

Avant de compiler le code, il faut charger les bibliothèques. Pour charger les bibliothèques, aller sur l’onglet Tool\MakerHub\LINX\Generate Firmware Librairies :

Et mettre en cible : C:\Program Files\Arduino\Libraries

Les librairies sont donc maintenant chargées et opérationnelles.

Configuration du type de carte

Avant de compiler le code, il faudra configurer le type de carte (Mega, Leonardo) et le type de liaison. Dans ce projet avec LattePanda, la carte Arduino Leonardo est utilisée sur le port COM 4. Dans LabVIEW cliquez dans l’onglet Tool puis \MakerHub\LINX\LINX Firmware Wizard… il faut configurer les champs à l’aide des informations mentionnées plus haut.

TEST simple avec une LED

Pour vérifier que la carte fonctionne correctement, l’exemple du pilotage d’une LED pourra être réalisé (onglet HELP/Find Example…). L’exemple est prêt à être utilisé et ne nécessite que la mise en place d’une LED en série avec une résistance de 220 Ω reliées au LattePanda.

Mettre le port COM 4 (normalement) et configurer la pin du Arduino sur laquelle est reliée l’anode de la LED (la patte la plus longue) et ne pas oublier la résistance de 220 Ω en série 😉 . Puis relier la résistance à la masse et lancer le programme (flèche blanche).

Si la LED clignote quand le bouton est pressé, c’est gagné. Passer aux étapes suivantes. Sinon, il faut trouver la raison de cette malchance.

Ne pas hésiter à reconfigurer la carte car il arrive (trop) souvent que cela saute au bout de 3 à 4 compilations. Par exemple, il vaut mieux arrêter proprement la boucle avec un bouton « stop » placé dans la boucle While plutôt que de stopper le programme avec le bouton rouge de LabVIEW.

L’IHM (côté « Face Avant » de LabVIEW)

L’IHM qui permet à l’utilisateur de contrôler les instruments pourra ressembler fortement à celle présentée ci-dessous.

Les configurations des Pins et du port sont situées à gauche.

Le bouton « Motor ON » permet d’activer le driver sur la Pin ENABLE (Driver).

Le bouton « Left » permet d’activer la Pin STEP (Driver)  et faire faire un pas au moteur.

Le bouton « Right »agit comme le bouton « Left » mais active la pin DIR (Driver) à l’état haut et permet de changer de sens de rotation.

Un bouton « Laser » permet d’activer le laser de visée.

Un bouton STOP permet d’arrêter l’exécution proprement et d’arrêter le moteur (ENABLE) et le Laser.

Trois types d’indicateurs sont présents : numérique (format chaîne de caractère), une barre de remplissage, et un graphe déroulant.

Un contrôleur barre graphe permet de passer au pilotage Pas par Pas (un clique sur LEFT ou RGTH = 0,9°) ou active la vitesse constante (comme sur la vidéo du début de l’article).

Pour le lecteur non initié à LabVIEW, la « face avant » est la partie visible finale du programme disponible pour l’utilisateur.

Le code est développé dans une seconde fenêtre appelée « Diagramme ». Et c’est la partie de développement du Diagramme que nous allons maintenant aborder.

Nota : un Crtl+E permet de permuter rapidement rentre la face avant et le diagramme.

La structure (côté diagramme)

La structure générale du programme est la suivante :

Figure 7 Structure générale du programme dans un boucle While

Le code source ne sera pas disponible dans cet article mais les principales briques seront détaillées pour arriver facilement au résultat. 🙂

Lecture de la valeur de la distance du Lidar

Le Lidar Garmin Lite V3 admet deux sorties de données pour la lecture des mesures : I2C ou PWM. La lecture en modulation de largeur d’impulsion est apparue comme le plus simple du point de vue du soft. Un VI LINX permet de réaliser cette mesure rapidement contre plusieurs VI pour la communication en I2C.

Dans la boucle While cadencée à 50 ms, la mesure du Lidar est effectuée à l’aide du VI « Lecture de la largueur d’impulsion » :

L’entrée DO Channel est connectée et la valeur de la Pin 0 de la carte Arduino est rentrée (cf Figure 8 ci-dessous).

Un tableau général de configuration des Pins d’E/S pourra être créé en amont de la boucle While comme ceci :

La valeur en sortie du VI n’est pas en cm mais en largeur d’une impulsion (µs), qui est proportionnelle à la distance mesurée en cm par le lidar. Afin de lire et d’afficher une valeur en cm, il faut diviser les valeurs en sortie du VI par une constante valant 10 pour obtenir une mesure de longueur (en cm). Cette constante est la sensibilité (en µs/cm) du capteur abordé précédemment que l’on peut retrouver dans la documentation du Lidar Lite V3 (page 4, §Mode Pin Control).

Une moyenne glissante pourra être développée afin d’obtenir une mesure plus stable et plus juste à l’aide des registres à décalage (flèches oranges sur les bords de la boucle While). L’inconvénient de cette technique est qu’il faudra attendre n fois le nombre de points moyennés, pour obtenir le résultat. Si l’on choisit de moyenner sur 10 points et que le temps du cadencement est de 500 ms, alors le résultat sera juste au bout de 5 secondes. Ne pas oublier d’initialiser les registres à décalage à zéro. Différents types d’indicateurs pourront être placés en face avant comme ci-dessous :

Figure 9 Moyenne glissante (côté diagramme/code) et exemples d’indicateurs en face avant

Comme le Lidar affiche une incertitude de ± 2.5 cm et une résolution de 1 cm, il a été choisi de n’afficher que des valeurs entières arrondies au centimètre.

VI de contrôle du Driver et du moteur

Un VI « écrire sur des E/S digitales » permet d’activer les sorties de l’Arduino du LattePanda afin de piloter le Driver.

La fonction suivante a été construite comme ci-après :

Cette fonctionnalité permet de prendre, en entrée, un tableau de booléens (ordres des boutons pressés en face avant) et d’activer les E/S correspondantes.

• La première entrée (en partant du haut) de la fonction « Construire un tableau» est reliée au bouton « MOTOR ON » et agit sur la Pin « ENABLE » du Driver. Ce bouton permet vraisemblablement d’activer l’alimentation du driver et du moteur.
• La seconde entrée permet de gérer la direction du moteur. Le fil (vert) est relié au bouton « RIGHT » de mon interface afin d’active la Pin « DIR » du driver. Le moteur tourne ainsi dans le sens horaire.
• La troisième entrée active la pin « STEP » du driver et permet d’effectuer un Pas de 0,9° (avec les entrées du driver MS1=MS2=MS3=0=GND). Le moteur effectue un pas par changement de niveau de l’état bas à l’état haut. Cette entrée est active si le bouton « LEFT » OU le bouton « RIGHT » est activé. Nous verrons ensuite comment faire tourner le moteur à vitesse constante.
• La quatrième entrée active le laser. Un laser de visée peut fonctionner qu’avec une tension de 5V et ne consomme que quelques milliampères. Il est souhaitable pour la sécurité des personnes, que le bouton « STOP » qui arrête le programme, puisse stopper l’émission du laser à la fin de la manip en même temps. Pour cela on pourra mettre une boucle conditions comme ci-dessous :

Il pourra être fait de même avec l’arrêt du moteur (« MOTOR ON ») à la fin de l’exécution du programme.

• Les cinquième, sixième et septième entrées activent les Pins MS1, MS2 et MS3 du driver et permettent de gagner en précision d’angle (jusqu’au demi pas ici).

Afin de faire fonctionner le moteur à vitesse constante, la fonctionnalité suivante a été développée :

Lorsqu’un booléen (bouton) active la structure « Cas », le VI « écrire un signal carré » est activé avec une fréquence nulle et d’une durée nulle sur la pin STEP. Cette fonctionnalité m’a permis de faire fonctionner le moteur à vitesse constante. Dans ce cas, la vitesse est fonction du temps de cadencement de la boucle (réglée à 50 ms). A l’heure où est écrit cet article, il existe surement de meilleures solutions, notamment avec le VI « PWM Set Duty Cycle »:

Mais cela n’a pas fonctionné comme il était souhaité lors du test.

A la suite de ces nombreux réglages et bidouillages, le programme doit pouvoir se lancer (flèche blanche non brisée). Si cela n’est pas le cas, résoudre les erreurs unes à unes.

Il fortement probable que rien ne fonctionne du premier coup, ou qu’à moitié, il est alors conseillé, dans un premier temps, de vérifier les branchements (alimentation) des organes dysfonctionnant.

L’utilisateur pourra jouer avec les différents types d’actions mécaniques pour contrôler le moteur (clique droit sur un bouton) :

Résultats en images :

Figure 10 Interface de la mesure de distance (Windows n’est pas à l’heure ^_^ )

J’espère que ce projet a pu continuer d’éveiller votre curiosité et a pu vous aider dans vos futurs développements !

Sources :

• Site Pololu (https://www.pololu.com/product/1182 )
• Site GO Tronic
• https://www.lattepanda.com
• Ressources LINX : https://sine.ni.com/nips/cds/view/p/lang/fr/nid/212478
• Forum LINX : https://www.labviewmakerhub.com/doku.php?id=libraries:linx:start
• Datasheet Lidar Garmin lite V3 : https://static.garmin.com/pumac/LIDAR_Lite_v3_Operation_Manual_and_Technical_Specifications.pdf
• LabVIEW – 4e édition – Programmation et applications – Introduction à LabVIEW NXG, Collection : Technique et ingénierie, Dunod, Parution : août 2018,Francis Cottet, Luc Desruelle, Michel Pinard

• The Art of electronic, Third edition, Paul Horowitz et Winfield Hill

Introduction

Quoi de plus normal pour un hacker que d’essayer de hacker tout ce qui bouge?

C’est probablement l’idée qui m’a traversé l’esprit quand j’ai mis en route ma première radiocommande: comment l’utiliser pour piloter tout et n’importe quoi? Une solution serait de concevoir intégralement un récepteur radio 2.4GHz et décoder le signal de la radiocommande. Cette solution permettrait de récupérer l’intégralité des voies de la radio. Elle est par contre particulièrement complexe.

C’est pourquoi, je vais vous proposer une solution détournée: récupérer les signaux de pilotage servomoteurs derrière un récepteur radio du commerce. Il suffit alors de lire les signaux modulés en largeur d’impulsion pour avoir la valeur émise par la radio.

Le montage que je vous propose permet de numériser les signaux destinés aux servomoteurs de modélisme. Les valeurs acquises sont ensuite envoyées à un PC via une prise USB.

Grâce au protocole HID, le montage est vu par le système d’exploitation (Windows, Linux, Mac) comme un joystick sans installer de pilotes particuliers.

Il ne reste plus qu’à exploiter les valeurs pour l’usage que vous aurez imaginé :

• Piloter un simulateur de vol sans fil
• Piloter un système déporté (robot, caméra IP, …)
• …

Un peu de théorie

Un récepteur de modélisme sert à recevoir et décoder les ordres émis par la radiocommande et les envoyer aux actionneurs (servomoteurs, variateurs, …). Le pilotage des actionneurs de modélisme est standard:

• Ils reçoivent des signaux carrés d’une période de 22 millisecondes
• La largeur de l’état haut varie entre 1ms et 2ms
• 1ms correspond à 0% (ou -100%)
• 2ms correspond à 100 %
• L’amplitude du signal est déterminée par la tension d’alimentation du récepteur

Il s’agit donc de signaux modulés en largeur d’impulsion ou PWM (Pulse Width Modulation).

Pour information, la largeur d’impulsion n’est que de 10% de la période totale pour permettre au récepteur de générer jusqu’à 10 voies séquentiellement:

Le fonctionnement du récepteur en est donc simplifié: il n’a qu’une impulsion à générer à la fois.

Mise en application

Choix du matériel

Le récepteur radio que j’ai choisi pour ce montage est un Spektrum AR400. Il s’agit d’un récepteur DSM2/DSMX 4 voies dédié à l’aéromodélisme. Il est en outre capable de gérer la télémétrie (future évolution du projet?).

Pour numériser les signaux PWM, je compte utiliser un microcontrôleur doté d’une connexion USB. Mon affinité me pousse naturellement chez Microchip. J’ai donc commencé le développement sur un PIC32MX795F512H que j’avais sous la main. Malheureusement, il se trouve que l’utilisation que je vais décrire dans cet article n’est pas bien supportée par mon compilateur, spécifiquement sur cette famille de PIC32. En effet, le contrôleur d’interruption ne semble pas bien configuré. Je suis donc passé sur un PIC32MX440F256H.

La carte de développement utilisée est une Pinguino Micro de chez Olimex, reprogrammée avec le bootloader USB de Mikroelektronika.

L’idée est d’utiliser les 4 modules Input Capture disponibles dans le PIC32. Ces modules permettent de faire des mesures temporelles sur des signaux digitaux. J’utilise donc un module par voie du récepteur.

Câblage

Le câblage électrique est des plus simple. La carte Pinguino est autonome. L’alimentation électrique provient directement de la prise USB. Un régulateur 3.3V présent sur la carte permet d’alimenter l’AR400 avec une tension compatible PIC32 (ces derniers peuvent être chatouilleux sur certaines broches avec le 5V par exemple).

Sur l’AR400, on note 5 rangées de 3 pins. De gauche à droite, on trouve:

• Association/Télémétrie
• Gaz
• Ailerons
• Gouverne de profondeur
• Gouverne de direction

Ensuite, de haut en bas, on trouve:

• Signal
• +Vcc
• Gnd

Voici donc le schéma de câblage (si l’on peut appeler ça comme ça…)

Le module Input Capture

Ce module est présent dans la plupart des microcontrôleurs Microchip. Il permet de récupérer la valeur d’un Timer sur un front de signal. Comme tous les modules d’un microcontrôleur, il est possible de le configurer:

• Choix du premier front de déclenchement (montant ou descendant)
• Mode de déclenchement (armement pour un front, sur les fronts montants, sur les fronts descendants, sur tous les fronts…)
• Périodicité des interruptions (tous les fronts, tous les 2 fronts, …)
• Pour les PIC32, choix de la taille du compteur (16 ou 32 bits)

J’ai choisi d’utiliser un Timer sur 32 bits, de déclencher sur tous les fronts, de commencer par un front montant et d’avoir une interruption à chaque déclenchement. Ce qui donne la configuration suivante (cf: datasheet du module Input Capture, page 6):

IC1CONbits.ICM = 0b110; //Simple Capture Event mode – every edge, specified edge first and every edge thereafter
IC1CONbits.FEDGE = 1; //Capture rising edge first
IC1CONbits.C32 = 1; //32-bit timer resource capture
IC1CONbits.ICI = 0; //Interrupt on every capture event
IC1CONbits.ICSIDL = 0; Continue to operate in CPU Idle mode
 
//Dupplication de la configuration sur tous les modules Input Capture    
IC2CON = IC1CON;
IC3CON = IC1CON;
IC4CON = IC1CON;

Cependant, le module Input Capture ne fonctionne pas seul: il travail conjointement avec le Timer 2. Il convient donc de le configurer également:

• Source d’horloge: interne
• Pas de prescaler (avec une horloge à 80MHz, la valeur de comptage devrait être comprise entre 80000 (1ms) et 160000 (2ms), ce qui donne une résolution plus qu’acceptable)
• Timer sur 32 bits
• Pas de GATE
• Période de comptage 0xFFFFFFFF

Ce qui donne la configuration suivante (cf: datasheet du module timer, page 9):

T2CONSET.f1 = 0; //Internal peripheral clock
T2CONSETbits.T32 = 1; //TMRx and TMRy form a 32-bit timer
T2CONSETbits.TGATE = 0; //Gated time accumulation is disabled
T2CONSETbits.TCKPS0 = 0; //1:1 prescale value
T2CONSETbits.TCKPS1 = 0;
T2CONSETbits.TCKPS2 = 0;
TMR2 = 0;
PR2 = 0xFFFFFFFF;
T2CONSETbits.ON = 1; //Module is enabled

NB : tous les modules Input Capture du PIC32MX440 accèdent au Timer2.

La routine d’interruption

La majorité du code contenu dans le microcontrôleur s’exécute sur interruptions. Sur front montant, je lis et mémorise la valeur du Timer2. Sur front descendant, je calcul la durée de l’impulsion en faisant la différence des valeurs courante et précédente du Timer2.

NB : Dès qu’un évènement est capturé par un module Input Capture, il copie la valeur du registre TMR2 dans le registre ICxBUF, qui est en réalité une FIFO. Elle stocke les valeurs de comptage des derniers évènements acquis.

void IC1_ISR() iv IVT_INPUT_CAPTURE_1 ilevel 6 ics ICS_SOFT {
     unsigned long temp = 0;
     LATG.f6 = 1;
     sync = 1;
     TMR1 = 0; //reset timeout comm.
     temp = IC1BUF;
     IC1BUF = 0;
     if (toogle1 == 0) {
         ic1_start = temp;
         toogle1 = 1;
     }
     else {
         // value1 = CalculDelta(temp, ic1_start);
         
         // Calcul T2-T1, même si le timer déborde et repart à 0
         if (temp<ic1_start) {
            // théoriquement impossible sauf en cas de débordement
            value1 = 4294967295-(ic1_start-temp)+1;
         }
         else value1 = temp-ic1_start;
         toogle1 = 0;
     }
     debug_toogle++;
     if (debug_toogle >= 50) {
        debug_toogle = 0;
        LATD.f1 = !PORTD.f1;
     }
     IC1IF_bit = 0;
}

Je profite de la disposition du Timer 1 pour gérer un timeout: en cas de perte de la liaison radio, le signal PWM disparait et le Timer 1 n’est plus remis à zéro. Le débordement du timer (environ en 200ms) indique une perte du signal. A noter également la gestion du débordement du Timer 2: à 80MHz sur 32 bits, il survient assez rapidement (53 secondes).

NB : La voie de pilotage des gaz génère tout le temps un signal. En cas de perte de la radiocommande, une impulsion de 1ms est envoyée pour remettre les gaz à 0.

Cette routine est dupliquée pour tous les modules Input Capture.

ATTENTION! il ne faut pas utiliser de sous fonction commune aux 4 interruptions: elle créent un couplage nuisible au fonctionnement du programme.

NB : Il est impossible de remettre à 0 le flag ICxIF_bit tant que le registre ICxBUF n’a pas été lu intégralement.

La communication USB

Dans un premier temps, j’ai choisi de remonter les valeurs des voies sur un PC via un bus USB. Le plus simple à gérer pour Windows est un périphérique HID compatible joystick. J’ai donc récupéré et nettoyé le descripteur USB de mon simulateur de Joystick. Le nouveau descripteur gère 4 axes (X, Y, Rx et Ry) sur 16 bits.

Voici le descripteur :

{
    0x05, 0x01,                        // USAGE_PAGE (Generic Desktop)
    0x09, 0x04,                        // USAGE (Joystick)
    0xa1, 0x01,                        // COLLECTION (Application)
    0x09, 0x01,                        //   USAGE (Pointer)
    0xa1, 0x00,                        //   COLLECTION (Physical)
    0x09, 0x30,                        //     USAGE (X)
    0x09, 0x31,                        //     USAGE (Y)
    0x09, 0x34,                        //     USAGE (Ry)
    0x09, 0x33,                        //     USAGE (Rx)
    0x15, 0x00,                        //     LOGICAL_MINIMUM (0)
    0x27, 0xff, 0xff, 0x00, 0x00,    //     LOGICAL_MAXIMUM (65535)
    0x75, 0x10,                        //     REPORT_SIZE (16)
    0x95, 0x04,                        //     REPORT_COUNT (4)
    0x81, 0x02,                        //     INPUT (Data,Var,Abs)
    0xc0,                            //     END_COLLECTION
    0xc0                            // END_COLLECTION
}

Le rapport USB envoyé au PC est décrit de la manière suivante:

typedef union {
    char bytes[8];
    struct {
        unsigned int x_value;
        unsigned int y_value;
        unsigned int rx_value;
        unsigned int ry_value;
    };
} T_USB_Report;

La boucle principale de programme est donc très simple: elle récupère les 4 valeurs, leur soustrait 80000 et les divise par 1.22. On obtient ainsi une valeur comprise entre 0 et 65573. Il convient de borner les valeurs finales obtenues en cas de dépassement de la gamme (<0 ou >65535). Les valeurs sont ensuite stockées dans le rapport USB et envoyées au PC.

while (1) {
    MyReport.x_value = (value1-MIN_PERIOD)/1.22;
    MyReport.y_value = (value2-MIN_PERIOD)/1.22;
    MyReport.rx_value = (value3-MIN_PERIOD)/1.22;
    MyReport.ry_value = (value4-MIN_PERIOD)/1.22;
    HID_Write(MyReport.bytes, sizeof(MyReport));
    delay_ms(10);
}

Ainsi, il devient possible de récupérer sous Windows les 4 voies de la radiocommande, en USB et sans driver spécifique:

Le programme complet

Voici le programme complet fonctionnel:

#include "USBdsc.c"
#define MIN_PERIOD        80000.0
 
typedef union {
    char bytes[8];
    struct {
        unsigned int x_value;
        unsigned int y_value;
        unsigned int rx_value;
        unsigned int ry_value;
    };
} T_USB_Report;
 
T_USB_Report MyReport;
 
int debug_toogle = 0;
 
unsigned long int ic1_start = 0;
unsigned long int value1 = 0;
int toogle1 = 0;
 
unsigned long int ic2_start = 0;
unsigned long int value2 = 0;
int toogle2 = 0;
 
unsigned long int ic3_start = 0;
unsigned long int value3 = 0;
int toogle3 = 0;
 
unsigned long int ic4_start = 0;
unsigned long int value4 = 0;
int toogle4 = 0;
 
int sync = 0;
 
char ReadBuffer[64], WriteBuffer[64];
 
unsigned long int CalculDelta (unsigned long int T2, unsigned long int T1) {
    // Calcul T2-T1, même si le timer déborde et repart à 0
    if (T2<T1) {
       // théoriquement impossible sauf en cas de débordement
       return 4294967295-(T1-T2)+1;
    }
    else return T2-T1;
}
 
void IC1_ISR() iv IVT_INPUT_CAPTURE_1 ilevel 6 ics ICS_SOFT {
     unsigned long temp = 0;
     LATG.f6 = 1;
     sync = 1;
     TMR1 = 0; //reset timeout comm.
     temp = IC1BUF;
     IC1BUF = 0;
     if (toogle1 == 0) {
         ic1_start = temp;
         toogle1 = 1;
     }
     else {
         // value1 = CalculDelta(temp, ic1_start);
         
         // Calcul T2-T1, même si le timer déborde et repart à 0
         if (temp<ic1_start) {
            // théoriquement impossible sauf en cas de débordement
            value1 = 4294967295-(ic1_start-temp)+1;
         }
         else value1 = temp-ic1_start;
         toogle1 = 0;
     }
     debug_toogle++;
     if (debug_toogle >= 50) {
        debug_toogle = 0;
        LATD.f1 = !PORTD.f1;
     }
     IC1IF_bit = 0;
}
 
void IC2_ISR() iv IVT_INPUT_CAPTURE_2 ilevel 5 ics ICS_SOFT {
     unsigned long temp = 0;
     temp = IC2BUF;
     IC2BUF = 0;
     if (toogle2 == 0) {
         ic2_start = temp;
         toogle2 = 1;
     }
     else {
         // value2 = CalculDelta(temp, ic2_start);
         
         // Calcul T2-T1, même si le timer déborde et repart à 0
         if (temp<ic2_start) {
            // théoriquement impossible sauf en cas de débordement
            value2 = 4294967295-(ic2_start-temp)+1;
         }
         else value2 = temp-ic2_start;
         toogle2 = 0;
     }
     IC2IF_bit = 0;
}
 
void IC3_ISR() iv IVT_INPUT_CAPTURE_3 ilevel 4 ics ICS_SOFT {
     unsigned long temp = 0;
     temp = IC3BUF;
     IC3BUF = 0;
     if (toogle3 == 0) {
         ic3_start = temp;
         toogle3 = 1;
     }
     else {
         // value3 = CalculDelta(temp, ic3_start);
         
         // Calcul T2-T1, même si le timer déborde et repart à 0
         if (temp<ic3_start) {
            // théoriquement impossible sauf en cas de débordement
            value3 = 4294967295-(ic3_start-temp)+1;
         }
         else value3 = temp-ic3_start;
         toogle3 = 0;
     }
     IC3IF_bit = 0;
}
 
void IC4_ISR() iv IVT_INPUT_CAPTURE_4 ilevel 3 ics ICS_SOFT {
     unsigned long temp = 0;
     temp = IC4BUF;
     IC4BUF = 0;
     if (toogle4 == 0) {
         ic4_start = temp;
         toogle4 = 1;
     }
     else {
         // value4 = CalculDelta(temp, ic4_start);
         // Calcul T2-T1, même si le timer déborde et repart à 0
         if (temp<ic4_start) {
            // théoriquement impossible sauf en cas de débordement
            value4 = 4294967295-(ic4_start-temp)+1;
         }
         else value4 = temp-ic4_start;
         toogle4 = 0;
     }
     IC4IF_bit = 0;
}
 
void USB_ISR() iv IVT_USB_1 ilevel 7 ics ICS_SRS {
     USB_Interrupt_Proc();
     USBIF_bit = 0;
}
 
void TMR1_ISR() iv IVT_TIMER_1 ilevel 1 ics ICS_SOFT {
     LATG.f6 = 0;
     /*
     value1 = 120000;
     value2 = value1;
     value3 = value1;
     value4 = value1;
     */
     sync = 0;
     TMR1 = 0;
     T1IF_bit = 0;
}
 
void ClearBuffer (char * buffer, int buffer_len) {
     int i = 0;
     for (i=0; i<buffer_len; i++) *(buffer+i) = 0;
}
 
void main() {
 
    toogle1 = 0;
    toogle2 = 0;
    toogle3 = 0;
    toogle4 = 0;
    ic1_start = 0;
    ic2_start = 0;
    ic3_start = 0;
    ic4_start = 0;
    value1 = 0;
    value2 = 0;
    value3 = 0;
    value4 = 0;
    debug_toogle = 0;
 
    AD1PCFG = 0xFFFF;
    JTAGEN_bit = 0;
    CHECON = 0x32;
    ODCB = 0;
    TRISD = 0xffff;
    TRISD.f1 = 0;
    TRISG.f6 = 0;
    LATG.f6 = 0;
    LATD.f1 = 0;
 
    IC1CONbits.ICM = 0b110;
    IC1CONbits.FEDGE = 1;
    IC1CONbits.C32 = 1;
    IC1CONbits.ICI = 0;
    IC1CONbits.ICSIDL = 0;
    
    IC2CON = IC1CON;
    IC3CON = IC1CON;
    IC4CON = IC1CON;
 
    T2CONSET.f1 = 0;
    T2CONSETbits.T32 = 1;
    T2CONSETbits.TGATE = 0;
    T2CONSETbits.TCKPS0 = 0;
    T2CONSETbits.TCKPS1 = 0;
    T2CONSETbits.TCKPS2 = 0;
    TMR2 = 0;
    PR2 = 0xFFFFFFFF;
    T2CONSETbits.ON = 1;
    
    PR1 = 65535;
    TMR1 = 0;
    T1CONSETbits.TCKPS0 = 1;
    T1CONSETbits.TCKPS1 = 1;
    T1CONSETbits.TGATE = 0;
    T1CONSETbits.SIDL = 0;
    T1CONSETbits.TCS = 0;
    T1CONSETbits.ON = 1;
 
    IC1IP0_bit = 0;
    IC1IP1_bit = 1;
    IC1IP2_bit = 1;
 
    IC2IP0_bit = 1;
    IC2IP1_bit = 0;
    IC2IP2_bit = 1;
 
    IC3IP0_bit = 0;
    IC3IP1_bit = 0;
    IC3IP2_bit = 1;
 
    IC4IP0_bit = 1;
    IC4IP1_bit = 1;
    IC4IP2_bit = 0;
    
    USBIP0_bit = 1;
    USBIP1_bit = 1;
    USBIP2_bit = 1;
    
    T1IP0_bit = 1;
    T1IP1_bit = 0;
    T1IP2_bit = 0;
 
    
    USBIE_bit = 1;
    IC1IE_bit = 1;
    IC2IE_bit = 1;
    IC3IE_bit = 1;
    IC4IE_bit = 1;
    T1IE_bit = 1;
    
    EnableInterrupts();
 
    HID_Enable(ReadBuffer, WriteBuffer);
    
    IC1CONbits.ON = 1;
    IC2CONbits.ON = 1;
    IC3CONbits.ON = 1;
    IC4CONbits.ON = 1;
 
    T4CONSETbits.ON = 1;
    
    while (1) {
          MyReport.x_value = (value1-MIN_PERIOD)/1.22;
          MyReport.y_value = (value2-MIN_PERIOD)/1.22;
          MyReport.rx_value = (value3-MIN_PERIOD)/1.22;
          MyReport.ry_value = (value4-MIN_PERIOD)/1.22;
          HID_Write(MyReport.bytes, sizeof(MyReport));
          delay_ms(10);
    }
}

 Conclusion

Ce montage assez simple à réaliser permet de récupérer dans un microcontrôleur, puis sur un PC, les valeurs de 4 voies radiocommandées.

L’utilisation du protocole HID permet de connecter le système sur n’importe quel PC ou autre RaspberryPi/LattePanda/BeagleBoard/…

Il devient donc possible de commander à longue distance un dispositif autonome. Les idées ne vous manqueront pas, j’en suis sûr 😉

Cet article fait suite à un précédent.

Introduction

Pour piloter ma fraiseuse, j’ai choisi la suite logiciel GALAAD. C’est un ensemble de logiciels dédiés CFAO. Plusieurs arguments ont justifié ce choix:

1. IronWood vend un pack qui comprend la machine, la carte d’interpolation Pulsebox NxTG
2. La dite carte d’interpolation est compatible plug’n’play avec GALAAD
3. J’ai eu l’occasion de voir réaliser des circuits imprimés avec cette suite logiciel à l’IUT d’Annecy
4. GALAAD est développé par des français
5. La licence d’utilisation adaptée à mes besoins n’est pas très onéreuse
6. GALAAD est compatible Windows 7, 8, 10
7. Je suis fan de Kamelott (et alors ?)

GALAAD est livré sur CD. Pensez-y, de nos jours les PC sont de moins en moins équipés de lecteurs optiques.

Une version d’évaluation est disponible ici: galaad.net

La licence de base n’a besoin de rien d’autre que le CD d’installation. En revanche, la version intégrale a besoin d’un dongle USB pour obtenir la licence d’utilisation.

Dans mon cas, je l’utilise sur un PC portable MSI GT683 tournant sous Windows 10 sans aucun problème de compatibilité ou d’instabilité.

D’autres solutions logicielles existent. En voici quelques unes avec les raisons qui m’ont fait y renoncer:

Mach3 CNC

http://www.machsupport.com/software/mach3/

Il s’agit d’un logiciel d’ancienne génération conçu pour piloter une machine à commande numérique directement via le port parallèle d’un PC. Pour les plus jeunes d’entre vous, le port parallèle était largement présent sur les PC et utilisé entre autre pour communiquer avec des imprimantes. Le port parallèle est accessible via une prise SubD-25. Bien connu des électroniciens (les niveaux électriques sont compatibles TTL 5V), ils tendent à disparaitre et ne sont même plus pris en charge par les versions de Windows supérieures à Vista.

Du coup Mach3 ne fonctionne que sous Windows Xp 32 bits sur un PC suffisamment vieux pour être équipé d’un port parallèle. Pas très pérenne comme solution… En outrer, le noyau de Mach3 (utilisé pour interpoler les déplacements de la machine et piloter les moteurs pas à pas) fonctionne également sous Windows. Le maitre mot du pilotage de fraiseuse est la bonne maitrise des signaux de pilotage. Or la régularité d’exécution d’un programme sous Windows est exécrable. Il suffit de brancher un périphérique USB, de lancer la calculatrice Windows, ou simplement d’avoir l’écran de veille du PC pour introduire un jitter immonde dans n’importe quel programme s’exécutant sur la machine. Croyez-moi, j’ai suffisamment pratiqué les systèmes temps réel pour vous déconseiller vivement cette solution.

Elle a cependant un avantage: pas besoin de carte électronique supplémentaire: on connecte directement la fraiseuse au PC via un prolongateur Sub-D 25.

PS: Une nouvelle version, curieusement appelée Mach4 (…) est sortie récemment. Je n’ai pas eu l’occasion de la prendre en main. Je n’émettrai donc aucun avis dessus.

Linux CNC

https://linuxcnc.org/

Il s’agit du cousin gratuit et Open Source de Mach3. Il se distingue principalement par le fait qu’il ne s’exécute que sous Linux.

Je ne suis pas linuxophobe, mais la majorité des logiciels que je compte utiliser pour fabriquer des pièces avec ma fraiseuse ne sont disponibles que sous Windows.

Je ne l’ai pas utilisé donc je ne suis pas le mieux placé pour en parler. Cependant, il existe des patch au noyau Linux pour exécuter des programmes temps réel et Linux CNC semble compatible. Il est donc fortement probable que les résultats soient meilleurs qu’avec Mach 3.

Description de la suite GALAAD

A l’inverse, des applications comme celles présentées ci-dessus qui s’occupent exclusivement du pilotage de la machine, GALAAD offre une solution intégrée allant du dessin à l’usinage. Voici les différents composants de GALAAD:

• GALAAD: module de CAO pour fraisage
• GAWAIN: module de CAO pour tournage
• KAY: module d’usinage/impression 3D
• KYNON: module de programmation script
• LANCELOT: module d’usinage 2.5D
• OWEIN: éditeur de fichiers GCode avec prévisualisation
• PERCIVAL: module de préparation à l’usinage de circuits imprimés

Vous aurez certainement identifié les différents chevaliers de la table ronde.

Les modules en vert sont inclus dans la licence de base. Le reste des modules est uniquement disponible en évaluation 30 jours. La licence de base peut paraitre restreinte, cependant elle offre les fonctions les plus intéressantes: pilotage de la machine et usinage de circuit imprimé. Il faudra par contre utiliser des logiciels tiers pour la conception et le dessin des pièces à réaliser.

ATTENTION: Percival n’est en aucun cas un logiciel de CAO électronique. Il sert uniquement à mettre en forme le PCB avant fabrication ; en tenant compte des outils disponibles sur la machine, des en simplifiant la gravure double face, … La CAO est toujours à réaliser par un logiciel conventionnel type EAGLE ou Proteus.

Installation et Mises à Jour

La suite GALAAD s’installe « à l’ancienne »: tout le contenu est copié dans le dossier C:\Galaad. Il n’y a pas de dépendances critiques avec la base de registre ou des DLL du système enfouies dans le System32. Une fois l’installation terminée, un dossier Galaad apparait également sur le bureau: il contient les raccourcis vers les différents modules.

Pour mettre à jour Galaad, rien de plus simple: il suffit de télécharger le patch au format compressé ZIP sur le site officiel et de l’extraire dans C:\Galaad en acceptant de remplacer les fichiers existants. On a beau dire, la simplicité à du bon !

Première utilisation

Connecter la Pulsebox NxTG sur le PC via le cordon USB fourni. Côté fraiseuse, j’ai dû utiliser un prolongateur Sub-D 25 (inclus) car le boitier de la Pulsebox est trop épais pour se loger dans la fente prévue pour la connectique de la StepCraft.

Les drivers devraient s’installer automatiquement:

Aucun driver particulier ne devrait être requis pour l’installation sur les versions de Windows récentes.

Démarrer ensuite le logiciel GALAAD (ignorer l’avertissement de sécurité de Windows…). Acquitter le popup informant des 30 jours de démo et ouvrir le menu Paramètres > Machine > Complets.

La fenêtre de configuration apparait.

Paramètres mécaniques

La première page permet de configurer les paramètres mécaniques de la machine.

Pour la StepCraft 420, voici la configuration à appliquer:

• Modèle: StepCraft ; 420 LPT (PulseBox)
• Type: 3 axes (ou 4 axes si équipée d’une tête d’impression 3D)
• Courses utiles:
  • X: 300 mm
  • Y: 420 mm
  • Z: 150 mm
• Pas des vis à billes:
  • X: 3 mm
  • Y: 3 mm
  • Z: 3 mm
•  Résolution des moteurs:
• • X: 400 pas/tour
  • Y: 400 pas/tour
  • Z: 400 pas/tour
• Axe supplémentaire (si équipée d’une tête d’impression 3D):
  • 4ème Axe: Axe E d’extrusion
  • Résolution: 200 pas/mm

Paramètres de commande numérique

La deuxième page concerne la commande numérique. A savoir la Pulsebox.

Pour utiliser la Pulsebox NxTG, voici ma configuration:

• Type: AxeMotion ; PulseBox NxtG
• Buffer mémoire locale cochée
• Interpol. 3D cochée
• Port: USB
• Baudrate: 115200
• Parité: Aucune
• Bits de donnée: 8
• Bits de stop: 1
• Contrôle de flux: Aucun
• Course de référence:
  • Position: Nord-Ouest
  • Séquence: ZYXAB
  • Avertir avant d’effectuer cochée

Paramètres avancés de la PulseBox NxtG

En cliquant sur le bouton Plus de la page de configuration de la commande numérique, après sélection du module de pilotage, une boite de configuration avancée apparait:

Il s’agit d’adapter la configuration de la PulseBox à la machine StepCraft.

Voici ma configuration:

• Fréquence Start/Stop: 200 Hz
• Accélération: 50 kHz/s
• Signal d’erreur ou arrêt sur l’entrée 2
• Pilotage manuel au JogPad cochée
• Utiliser les vecteurs à pente cochée
• Vitesse d’approche: 50 mm/s
• Dégagement hors contacts: 1 mm
• Affectation des signaux SUB-D25:
  • Ligne 1: Sortie N°1
  • Ligne 2: Direction X
  • Ligne 3: Impulsions X
  • Ligne 4: Direction Y
  • Ligne 5: Impulsions Y
  • Ligne 6: Direction Z
  • Ligne 7: Impulsions Z
  • Ligne 8: Direction A
  • Ligne 9: Impulsions A
  • Ligne 10: Entrée N°1
  • Ligne 11: Entrée N°2
  • Ligne 12: Entrée N°3
  • Ligne 13: Entrée N°4
  • Ligne 14: Sortie N°2
  • Ligne 15: Entée N°5
  • Ligne 16: Sortie N°3
  • Ligne 17: Sortie PWM
• Affectation des signaux broches 1 à 9:
  • Broche 2: Sortie N°4
  • Broche 3: Sortie N°5
  • Broche 4: Sortie N°6
  • Broche 5: Entrée N°6
  • Broche 6: Entrée N°7
  • Broche 7: Entrée N°8
  • Broche 8: Entrée N°9
  • Broche 9: Entée N°10

Paramètres de la broche

La troisième page concerne la broche d’usinage.

Il est possible de laisser les paramètres par défaut, à savoir Aucune Broche. En effet, la StepCraft n’est pas équipée pour piloter une broche. Dans mon cas, la broche Kress est munie d’un variateur réglable à la main et d’un interrupteur Marche/Arrêt manuel. J’envisage cependant de la piloter avec un contacteur en utilisant l’une des sorties DO de la Pulsebox. Dans ce cas, il faut configurer GALAAD pour utiliser une broche standard en lui donnant les sorties à activer pour la mise en route. Je donnerais plus de détails quand le relais sera installé et testé.

Paramètres de vitesse

La quatrième page concerne les vitesses atteignables par la fraiseuse. Si elles sont trop élevées, la machine ne fonctionnera pas correctement. Voici une configuration satisfaisante:

• Vitesse mini: 6mm/min
• Vitesse maxi: 3000 mm/min
• Multiplicateur: 1
• Course de référence: 600 mm/min
• Mouvement inactifs XY: 3000 mm/min
• Descentes inactives Z: 3000 mm/min
• Remontées Z: 3000 mm/min
• Descente sur capteur: 600 mm/min
• Descente du palpeur: 600 mm/min
• Pilotage manuel:
  • Valeurs par défaut:
    • XY: 600 mm/min
    • Z: 600 mm/min
  • Accélération progressive cochée
  • Répétition cochée

Paramètres avancés

Viennent ensuite les paramètres avancés:

Les facteurs d’échelle sont à 1.

Les axes de déplacement X, Y, Z et E sont respectivement associés aux Canaux 1, 2, 3, et 4. Petit bémol tout de même: la commande de l’axe 1 est inversée.

Les corrections de perpendicularité et de rattrapage des jeux sont à évaluer et renseigner par vos soins. Je n’ai pas encore pris le temps de les mesurer: les valeurs sont donc à 0.

Paramètres des Entrées/Sorties

Voici enfin le moment de configurer les E/S de la machine.

Pour une StepCraft de base, il suffit éventuellement de lui dire d’arrêter l’usinage si l’entrée correspondant à l’arrêt d’urgence est active. Dans mon cas, j’ai simplement configuré mon calibrateur de hauteur d’outil.

Premiers mouvements

Les premiers mouvements à réaliser sont une prise d’origine machine.

Pour ce faire, quitter GALAAD et lancer LANCELOT.

Annuler l’ouverture de fichier. Un popup apparait pour prévenir que la machine fait effectuer une course de référence. A ce moment, il convient de garder la main posée et prête à l’action sur le bouton d’arrêt d’urgence. Au cas où un contact de prise d’origine soit mal câblé ou défectueux, il serait dommage d’emmener un axe en butée. Peu de dommages sont à prévoir dans ce cas: les moteurs pas à pas vont « gripper » et sauter des pas. Le couple exercé n’est pas suffisant pour véritablement endommager la machine, mais le bruit n’a rien de plaisant…

Cliquer sur OK et observez votre fraiseuse qui se positionne au fond à gauche avec l’axe Z tout en haut.

Félicitation: votre StepCraft semble fonctionner et fonctionnelle !!!

Pour aller plus loin dans les tests, il est possible d’utiliser la palette de pilotage manuel:

Une croix directionnelle et deux sélecteurs haut/bas permettent de déplacer la broche. Les commandes sont également accessibles au clavier: flèches directionnelles pour XY et +/- du pavé numérique pour Z.

Il est également possible de tracer 4 formes de base en mode manuel, de gauche à droite sur l’IHM:

• Un perçage à une position X,Y et une profondeur Z
• Une ligne entre la position courante et une position cible X, Y à la profondeur et vitesse voulue
• Un rectangle entre la position courante et une position X, Y à la profondeur et vitesse voulue
• Un cercle autour de la position courante avec le rayon et la vitesse voulue.

Ces formes de base, associées à l’installation d’un bon stylo à bille sur la fraiseuse et l’utilisation d’une feuille de papier vont permettre en première approche de vérifier les paramètres de la machine.

Normalement, tous les modules de GALAAD interdisent les mouvements impossibles à la machine. Concrètement, il est impossible de taper les fins de courses en pilotage manuel (contrairement au mode Déblocage manuel accessible depuis le module GALAAD). Attention cependant pour les déplacements à proximité des extrémités: des parties de ma tête d’impression 3D sont entrées en collision avec les montants de la fraiseuse. Préférez du coup travailler au centre de la zone de travail: la rigidité de la StepCraft et la précision des moteurs l’autorisent sans aucun problème.

Je reviendrai plus longuement sur l’utilisation des différents modules de GALAAD au fil d’autres articles sur la CFAO.

A Bientôt pour de nouvelles aventures !

Avertissements:

Cette réalisation a pour but de générer de hautes tensions. Il vous revient de prendre toutes les précautions nécessaires pour ne pas vous mettre en danger ou endommager vos appareils électroniques!

Historique

Comme son nom l’indique, le résonateur Tesla est l’une des inventions du savant Serbe Nikola Tesla. Né le 10 juillet 1856 à Smiljan, Nikola Tesla entre à l’école Polytechnique de Graz en 1875. Il y assimilera deux années d’études en un an seulement avant de quitter l’université faute d’argent. Il commence son travail d’ingénieur en 1881 pour l’Office du télégraphe à Budapest. À l’avènement du téléphone, il est promu chef électricien puis ingénieur-chef de la compagnie. On lui devrait le premier haut-parleur. En 1882, il vient travailler à Paris pour la société Continental Edison où il finit de mettre au point le premier moteur à induction. Il expérimente les résonateurs hautes fréquences entre 1899 et 1900 dans le but de créer une tour de télécommunications. Ce sont les fameuses bobines de Tesla.

Source: Wikipedia

Principe de fonctionnement du résonateur Tesla

L’objectif du résonateur Tesla est de produire des champs électriques intenses à haute fréquence. L’idée de Tesla repose sur deux principes fondamentaux:

• L’utilisation d’un transformateur
• L’utilisation de la résonance

Un transformateur électrique est chargé d’augmenter ou d’abaisser une tension électrique sinusoïdale en utilisant le couplage magnétique de deux bobines aux nombres de spires différents. Le rapport de transformation est alors donné par le rapport du nombre de spires de la bobine secondaire sur le nombre de spires de la bobine primaire. Le résonateur Tesla est un transformateur élévateur de tension comportant très peu de spires au primaire (une dizaine) et beaucoup plus au secondaire (plusieurs milliers).
L’idée de génie de Tesla fut d’utiliser ce transformateur à sa fréquence de résonance. Pour ce faire, il place un condensateur en série avec le primaire et un autre en série avec le secondaire. Les valeurs des condensateurs sont choisies pour que les deux circuits LC résonnent à la même fréquence.
La haute tension est alors produite par la décharge répétitive du condensateur dans la bobine primaire. Le transformateur entre en résonance (autour de 500kHz) et un très haut potentiel électrique apparait sur le condensateur secondaire.

Schéma d’un résonateur Tesla

On retrouve le condensateur primaire, les bobines primaire et secondaire, ainsi que le condensateur secondaire qui est en réalité soit un tore soit une sphère métallique. Un interrupteur est chargé de connecter périodiquement le condensateur primaire à la bobine primaire. Quand l’interrupteur conduit, le condensateur se décharge dans la bobine et le circuit primaire entre en résonance. Quand l’interrupteur est ouvert, le condensateur se charge à la tension d’alimentation du résonateur.

Particularité d’un résonateur à éclateur solide

Les bobines de Tesla conventionnelles sont alimentées en haute tension alternative (de l’ordre de 10kV). L’interrupteur du primaire doit donc être capable de commuter de très forts courants sous une tension de 10kV à la fréquence d’alimentation de la Tesla (50 Hz en France). Pour réaliser ma mini Tesla, j’ai choisi d’utiliser une alimentation 12V continue et de mettre un transistor MOS comme interrupteur primaire. Ceci présente plusieurs avantages, comme notamment la possibilité de régler la fréquence de commutation du MOS en jouant sur la fréquence du signal de grille.

Réalisation

La première chose à faire est de bobiner le secondaire. Assurez-vous au préalable d’avoir tout ce qu’il faut… Pour ma bobine secondaire, j’ai bobiné du fil de cuivre de 0.125mm de diamètre sur un tube de PVC de 32mm sur une longueur d’environ 10cm (le fil a cassé avant que j’atteigne mon objectif de 15cm…). Qu’à cela ne tienne, je poursuis ma réalisation!!!
Pensez bien à laisser suffisamment de mous au fil de cuivre de chaque côté de la bobine pour permettre les connexions électriques. Ensuite: la bobine primaire. Pour celle-là, rien de plus simple: quelques tours de fils de cuivre (celui que vous avez, pour moi du 0.75 mm²) sur un tronçon de PVC de plus grand diamètre que celui du secondaire et voilà! Ensuite, le condensateur secondaire. Le mien est une balle de ping-pong soigneusement recouverte de scotch aluminium.
Enfin: le circuit électronique de commande. Pour simplifier la réalisation, je génère la commande du MOS avec mon GBF, mais rien n’empêche de construire un petit oscillateur avec un 555 pour rendre votre réalisation parfaitement mobile. L’alimentation 12Vdc est tirée d’un vieille alimentation de PC (et alors 😉 ). Attention toutefois à ce que votre alimentation soit assez tolérante aux retours de hautes fréquences et aux courts-circuits! Le schéma n’a en sois rien de compliqué:

On retrouve le condensateur primaire connecté directement à la source, le PMOS intercalé entre le condensateur et la bobine du secondaire. Attention: le PMOS conduit quand la grille à un potentiel inférieur à Vcc – 5V et il est bloqué quand le potentiel de grille est égal à Vcc. Si vous avez un NMOS sous la main, n’hésitez surtout pas à modifier le schéma!

Les premiers essais

Après avoir relié l’alimentation, le signal de commande du MOS et relié le bas de la bobine secondaire à la masse, il ne reste plus qu’à mettre en route! Selon la fréquence du signal de commande, on peut isoler deux modes de fonctionnement:

Fréquences basses (de l’ordre du kHz): le résonateur fonctionne comme Tesla l’avait prévu: la capacité du primaire entre en résonance avec la bobine. J’ai réussi à produire des étincelles d’un petit millimètre. Assez décevant me direz-vous, mais ces fréquences sont audibles et l’on peut faire chanter la Tesla!

Fréquences élevées (environ 750 kHz): la capacité n’a plus le temps de se charger ou de se décharger et la bobine primaire entre directement en résonance avec la tension hachée fournie par le MOS. Cette fois, les étincelles atteignent facilement le centimètre.

Pour trouver la fréquence de résonances, il y a deux écoles: à l’oscilloscope (méthode « propre ») ou au tube fluo (méthode « amusante »). A l’oscilloscope, il suffit laisser la sonde posée négligemment sur le plan de travail à proximité de la Tesla pour observer les signaux HF rayonnés par la Tesla. Avec un tube fluo, c’est le même principe: il faut saisir le tube par une électrode et approcher l’autre de la Tesla. Le fluo devrait s’allumer. Ensuite, que vous utilisiez le fluo ou l’oscilloscope, il faut régler la fréquence de commande du MOS pour obtenir la plus grande amplitude de signal (à l’oscilloscope) ou la plus forte luminosité (au fluo).

NB: si vous n’avez pas de fluo, une ampoule à économie d’énergie (fluocompacte) ou même une simple LED feront l’affaire.

On peut remarquer la taille impressionnante du dissipateur thermique du MOS. Tous d’abord, je n’en avais pas d’autre (eh oui, ça joue…), ensuite, à basse fréquence, le courant circulant dans le MOS peut provoquer un échauffement très intense (mon premier MOS mourut ainsi dans d’atroces souffrances). Donc, ne négligez pas le refroidissement du MOS: un accident est vite arrivé!

Le kit Stepcraft contient l’intégralité des pièces mécaniques, de la visserie et de l’accastillage en tout genre.

Pour le montage, il vous faudra vous munir des outils suivants:

• Un jeu de clés allen (de 1.5mm à 5mm coudées)
• Un jeu de clés plates (de 5.5mm à 10mm)
• Une pince à bec
• Un canif
• Une paire de petits tournevis plats d’électricien
• Un rouleau de scotch d’électricien
• un tube de colle cyanoacrylate (Super Glu)
• Un peu d’huile
• Du temps libre

Le kit est fourni avec une notice de montage aussi détaillé que les notices de LEGO ! Ainsi équipé, le montage est réellement une partie de plaisir.

Pour plus de détails et d’informations, des clips vidéos explicatifs sont disponibles sur youtube.

Pour ne pas plagier la notice de montage, je vais plutôt mettre en valeur les points d’achoppement possible et toutes les erreurs que j’ai commises pour vous éviter de les imiter.

Tout d’abord, le montage ne pose pas de difficultés techniques majeures. Il suffit juste d’être attentionné et de suivre les étapes dans l’ordre:

1 – Le montage de la plaque de couplage des axes X et Z

Cette partie du montage commence par l’installation des deux capteurs de prise d’origine machine (la POM dans le jargon). Ils sont montés sur des entretoises, bien protégés au milieu de la plaque. La détection d’origine à lieu lorsqu’une glissière en aluminium entre en contact avec le bâtis de l’axe. La glissière transmet alors le mouvement vers le capteur. Penser juste à ne pas trop bloquer les vis qui maintiennent la glissière, bien que des rondelles soit présentes pour la laisser libre de ses mouvements.

Les capteurs sont câblés en série; il n’y a donc que deux fils à tirer. Ils sont logés dans des lumières taillées dans la masse de la plaque de couplage et maintenus en place par des plaques de plastique rigide autocollantes (visibles en blanc sur la photo). Une rotule en plastique permet de recevoir les deux gaines annelées qui guideront les câbles des capteurs et des moteurs.

La plaque de couplage reçoit les dispositifs de guidage pour les axes X et Z. Ils sont constitués de quatre galets en laiton montés chacun sur deux roulements à bille graissés à vie. Deux galets par axe son fixe, les deux autres sont montés dans des trous oblongs et munis d’une vis transversale de réglage. Cette vis permettra d’éliminer les jeux de guidage. Enfin, un écrou trapézoïdal par axe est monté au milieu de la plaque. Ils sont prévus pour recevoir les vis de 10mm chargées de transmettre les mouvements de rotation.

Cette phase de montage ne présente aucune difficultés. Il faudra simplement veiller à ne pas trop serrer les vis en prise dans les pièces en laiton. Ce dernier étant très tendre, un serrage trop intense détruira irrémédiablement le filet du filetage. Il faudra également essayer de « centrer » les écrous trapézoïdaux. Concrètement, il faut engager la vis à la main et vérifier à la louche que l’amplitude du jeux de cette dernière dans l’écrou soit réparti équitablement par rapport à l’axe de la plaque.

2 – Le montage de l’axe Z

La deuxième étape consiste à assembler l’axe Z de la machine. Elle commence par l’accouplement de la vis au moteur pas à pas. Une butée métallique doit être collée à la Super Glu sur le moteur. On veillera à ne se coller ni les doigts, ni l’axe du moteur. Un accouplement en laiton est bridé sur l’axe du moteur et sur la vis. Une goute d’huile ou de graisse sur la butée est nécessaire pour limiter les frottements: la butée va supporter tout le poids de l’axe Z… Les 4 fils du moteur pas à pas sont en vrac. Il sont à glisser dans une gaine annelée pour les protéger. Un morceau de scotch d’électricien fait parfaitement l’affaire pour aiguiller les fils dans la gaine. Le moteur est fixé par quatre vis sur une plaque elle-même vissée à l’une des extrémité du profilé de guidage. L’autre extrémité de l’axe est constitué de la plaque porte outil. La vis de transmission est montée sur roulement à bille au niveau de cette plaque. L’outil est prévu pour se monter dans un trou de 43mm fendu et serré par une vis.

Dans l’ordre, on glisse la plaque de couplage dans le profilé, on introduit la vis dans l’écrou et on approche au maximum la plaque de couplage du moteur. Ensuite, on serre les trois vis qui fixe le support moteur sur le profilé. On approche la plaque de couplage au plus près du porte outil, à l’autre extrémité de la vis, et on serre les trois vis de fixation dans le profilé. On s’assure ainsi du bon centrage du moteur et du porte outil. Sans cette précaution, la vis ne serait pas concentrique avec le profilé et l’axe pourrait méchamment gripper. Cette manipulation sera à mener pour chacune des vis de la fraiseuse.

Les deux vis montés sur deux des galets de la plaque de centrage permettent de supprimer les jeux.

3 – Le montage de l’axe X (la potence)

La potence supportant l’axe X est constituée de deux plaques d’aluminium massif et d’un profilé de guidage. La première étape est d’accoupler la vis au moteur. Le même principe que pour l’axe Z est employé.

Chaque montant de la potence est équipé de quatre galets de guidage et d’un écrou. En effet, l’axe Y sera muni de deux vis de transmission. Le réglage des galets de la potence et du centrage des écrou est à effectuer de manière préliminaire avant l’assemblage de l’axe Y. Une fois les réglage terminé, on peut insérer la plaque de couplage de l’axe Z dans le profilé et mettre la vis en place. Avant de serrer les montants de la potence sur le profiler, veiller à bien amener l’axe Z au plus proche du côté concerné, encore une fois afin de garantir un bon centrage de la vis de transmission. Enfin, il faut passer les câbles de l’axe Z dans une lumière le long d’un des montant. Ils sont maintenus en place par des plaques de plastique autocollant. Prenez garde en manipulant la potence, l’ensemble commence à peser un certain poids.

4 – Préparation de l’axe Y

L’axe Y représente le plus gros morceau de la machine: il en constitue la base. Avant de commencer son assemblage, il est nécessaire de réaliser quelques sous assemblages.

Le premier d’entre eux est le moteur de l’axe Y. Ce dernier est motorisé par un moteur pas à pas plus gros que les deux autres axes. Il est couplé sur les deux vis de transmission par une courroie crantée. Il faut donc commencer par monter la poulie crantée sur le moteur. Elle est bridée sur l’axes par une petite vis sans tête. Attention de ne pas la perdre !

Le deuxième sous ensemble est le troisième capteur de prise d’origine. Le switch est monté sur une équerre en aluminium à l’aide de deux vis.

Ensuite, il faut assembler les deux capots latéraux qui vont protéger les transmissions de l’axe Y. Ces capots sont constitués d’une longueur de profilé d’aluminium articulée autour de deux pionts en nylon montés à force dans deux rainures. Ils sont maintenus en position par deux billes montées sur ressort. Elles sont elles aussi montées à force dans deux rainures. Enfin, un joint plat en silicone est glissé dans une fente tout le long du profilé. Il empêchera les copeaux de se coincer dans la transmission.

5 – Assemblage de l’axe Y et de la base de la machine

La base de la machine est supportée par deux profilé de guidage. Ils sont maintenus à chaque extrémité par deux plaques d’aluminium massif. La plaque de derrière reçoit le capteur fin de course, le moteur pas à pas, le galet tendeur de courroie et la première partie du capot de dessous. Les deux profilés de guidage sont vissés sur cette plaque. On ne serrera pas les vis avant d’avoir mis les vis de transmission. Les deux profilés sont munis du même joint plat en silicone que les capots de protection.

Le fond de la machine se glisse dans deux rainures en bas des profilés afin de conférer à l’ensemble un début de rigidité.

La face avant reçoit elle le bouton d’arrêt d’urgence.

Vient maintenant la phase de l’assemblage final. On monte les deux profilés sur la plaque de derrière sans serrer les vis. On glisse la potence à sa place dans les deux rails de guidage de l’axe. On serre les quatre galets de guidage pour supprimer les jeux. On introduit les deux vis de transmission dans les écrous, sans les engager dans leur roulements à bille. Il faut contrôler le jeux des vis: en jouant avec cette dernière de haut en bas, l’écart par rapport à l’axe doit être réparti équitablement. Il est possible d’utiliser le roulement à bille comme point de repère. Ensuite, il est possible de monter les vis en position et de serrer le plaque de derrière, après avoir ramener la potence en butée sur la plaque de derrière.

La prochaine étape consiste à installer la transmission: une poulie crantée sur chaque vis, une courroie pour synchroniser le tout et un galet tendeur pour maintenir la courroie en place. Il est capital de s’assurer que les deux montant de la potence sont parfaitement alignés avant d’engager les crans de la courroie sur les poulies. Pour se faire, il est possible d’utiliser en guise de cale les pieds de la machine en plastique dur. Une fois la courroie bien en place, un capot en aluminium recouvre la transmission et la protège des chocs mécaniques.

On installe les deux capots de protection des vis en glissant les deux pions en nylon dans les trous idoines. On ajoute les deux butées à bille au bout des vis de transmission et on ajoute la face avant de la machine. Avant de serrer les vis, bien ramener la potence en butée sur la face avant.

La fraiseuse commence à ressembler à quelque chose. Plus que la dernière ligne droite: le câblage!

6 – Câblage des actionneurs et installation de la carte de commande

Il s’agit maintenant de ramener tous les câbles de la machine vers le logement prévus sous le fond du châssis. Ce logement accueil la carte de commande. Une face-arrière en plastique découpée selon les empreintes des différents connecteurs évite l’entrée de copeaux dans le logement de la carte. Cette dernière se monte sur six entretoises. Avant de monter la carte dans son emplacement, il faut lui brancher le module d’interface PC. Il en existe trois différents: port parallèle, liaison série RS232 ou USB. Il s’agit d’une petite carte électronique munie d’un connecteur à broches d’un coté et de la prise PC de l’autre. Dans mon cas, il s’agit d’un module pour port parallèle: le carte ne contient aucune électrique et se contente de router les signaux de commande vers un SUB-D 25. Chaque moteur pas à pas est prévu pour se brancher sur un bornier quatre broches à vis. Un bornier plus grand reçoit les capteurs de POM, l’arrêt d’urgence et le calibreur de hauteur d’outil (en option, mais indispensable). Un couvercle monté dans une rainure et fixé par deux vis vient refermer le logement de la carte de pilotage.

7 – Fignolage

Avant la première mise en route, il reste quelques détails à régler:

1. Installer les pieds autocollants sous les profilés de guidage
2. Glisser le plan de travail dans les rainures du châssis
3. Monter la plaque de fixation du plan de travail (prévu pour être facilement démontée)
4. Coller les stickers qui vont bien
5. préparer les deux barres de bridage pour tenir vos pièces
6. Graisser généreusement les parties en mouvement avec la graisse fournie

Vous voilà fin près à usiner !

Reste quand même à installer le logiciel, configurer la machine, dessiner des pièces, …

Acquisitions sur le terrain, télégestion, domotique… De nombreuses applications s’accommodent très bien d’une connexion à l’Internet. Qu’il s’agisse d’envoyer des mesures dans une base de données ou de piloter un système à distance: les idées ne manquent pas.

Je vous propose aujourd’hui une petite carte comprenant un microcontrôleur et l’interface réseau qui va lui permettre de dialoguer avec un modem.

Ce projet est rendu possible par Microchip qui propose un contrôleur réseau en boitier DIP28 simplement commandé par un bus SPI. Ce fameux composant se nomme ENC28J60. Il ne requiert que très peu de composants annexes: quelques condensateurs et résistances, un quartz à 25.000 MHz et, bien évidemment, une prise RJ45 et son transformateur de couplage.

Le schéma

Assez palabré, jetons un coup d’œil au schéma.

L’alimentation

J’ai choisi d’utiliser un PIC 18F qui fonctionne sous 5V, mais l’ENC fonctionne lui en 3.3V. Il y a donc deux régulateurs de tension: le premier fournit le 5V au micro et le second fournit le 3.3V à l’ENC. J’ai d’abord monté ces deux régulateurs en parallèle alimentés par le 12Vdc, mais pour limiter l’échauffement du LM317, je l’ai ensuite monté en cascade derrière le régulateur 5V (passant du même coup d’un classique 7805 à un PT78ST105 à découpage).

Il serait peut-être plus avantageux d’utiliser un PIC18LF alimenté directement en 3.3V. Mais vu la consommation de l’ENC (250 mA), il ne semble pas utilise de gratter quelques mA sur le PIC.

L’ENC28J60

L’ENC28J60 est un microcontrôleur, certes un peu particulier, mais qui a les mêmes besoins: une horloge, une alimentation découplée et un Reset.

Le quartz imposé par Microchip doit résonner à 25 MHz. C’est une fréquence courante pour les contrôleurs réseau: on peut donc récupérer de tels quartz dans de vieux routeurs, par exemple. Autrement, ils sont disponibles en neuf chez Conrad.

La connexion à la prise réseau doit obligatoirement passer par un transformateur de couplage. Là encore, il est possible d’en récupérer dans de vieux routeurs. Il existe aussi des prises réseaux intégrant le transformateur appelées « magjack ». C’est une prise de ce type que j’ai utilisé (récupérée dans une vielle Livebox Sagem).

La connexion avec le PIC passe par un bus SPI. Ce dernier transporte les informations sur deux fils (SDI et SDO) accompagnées d’un signal d’horloge (SCK). Il suffit donc de relier la broche SDO du PIC à la broche SI de l’ENC, SDI sur SO et SCK sur SCK. Il faut aussi compléter ce bus des deux lignes /RESET et /CS (chip select), qui permettent d’initialiser le composant et de le choisir (si le bus SPI est relié à d’autres périphériques).

Enfin, Une self permet d’isoler l’alimentation de la carte avec la liaison Ethernet (très bruitée).

ATTENTION: comme je l’ai déjà signalé, l’ENC fonctionne en 3.3V et le PIC en 5V. Dans le cas d’un PIC, les entrées du bus SPI sont dites à « trigger de Schmitt ». En gros, cela signifie qu’elles sont compatibles avec les signaux 3.3V. Pour d’autres microcontrôleurs, il peut être nécessaire d’ajouter un circuit d’adaptation de niveau sur les lignes SDI et /INT. Par contre les entrées de l’ENC sont compatibles TTL 5V. Il n’est donc pas nécessaire d’abaisser le niveau 5V à 3.3V avant d’entrer dans l’ENC.

Le Microcontrôleur

Je suis d’abord parti sur un PIC18F4550, bien connu, qui offre la possibilité d’utiliser le bootloader USB de l’Interface HID Universelle. Malheureusement, bien que milieu de gamme, ce contrôleur n’offre presque pas suffisamment de ressources pour utiliser une stack TCP/IP ou UDP/IP. J’ai donc migré vers un PIC18F46K80. Avec ses deux UART et son bus CAN, ce microcontrôleur est parfaitement adapté à la communication sur réseaux de terrain (je le réservais d’ailleurs à la réalisation d’un espion RS232 …). Il offre cependant 64 ko de flash et 3.6 ko de RAM (contre 32ko de flash et 2ko de RAM pour le 4550) et des convertisseurs A/N 12 bits (contre 10 bits pour le 4550).

Le PIC18F46K80 permet de programmer un mini serveur web ou d’implanter une petite stack TCP/IP pour envoyer des infos sur une base de données (par exemple).
ATTENTION: le 46K80 n’est pas entièrement compatible avec le 4550: les broches d’alimentations sont identiques, mais le bus SPI n’est pas à la même place. En outre, comme le module USB disparaît, la configuration de l’horloge diffère et il faut ajouter un connecteur ICSP (pas de bootloader pour le 46K80, sauf peut-être un en Ethernet …).

Overclocking

Pour les néophytes, l’overclocking est l’art de faire fonctionner un système informatique plus rapidement que ce que préconise le fabricant. Fort populaire sur PC, l’overclocking peut aussi s’appliquer à nos chers microcontrôleurs.

Dans le cas du 18F46K80, il s’agit surtout de conserver le quartz de 20MHz que j’avais mis pour le 4550. Le 46K80 offre une configuration d’horloge complètement différente du 4550. Il est notamment possible de configurer l’utilisation d’une horloge secondaire plus lente pour le mode basse consommation. Par contre, il ne propose qu’une seule PLL d’un coefficient de 4. On a donc le choix entre une horloge à 20MHZ ou une horloge à 80MHz. Je vous laisse imaginer quelle configuration j’utilise ;). Par contre, cette fréquence dépasse de 25% les spécifications constructeur, donc si votre micro a un comportement anormal, désactivez la PLL et contentez-vous d’une horloge à 20MHz.

NB: Il est bien connu qu’un microprocesseur de PC chauffe plus quand on l’overclocke. Un PIC n’est pas différent: si le 46K80 est froid à 20MHz, il tiédit légèrement à 80MHz (mais rien de comparable avec l’ENC28J60, qui lui tiédit franchement).

Utilisation

Une fois n’est pas coutume, j’utilise l’environnement MikroC pour programmer cette carte. En effet, MikroC offre une bibliothèque dédiée à l’utilisation de l’ENC28J60. Je vous invite à essayer leurs exemples, notamment leur serveur web.

Une version modifiée et améliorée de leur stack TCP/IP est disponible sur leur dépôt Libstock.

Voici un exemple de code :

#include "__NetEthEnc28j60.h"
#include "recources.h"
 
#define TMR0_PRE                    34286    //une IT toutes les 200ms à 80MHz
 
// mE ehternet NIC pinout
sfr sbit Net_Ethernet_28j60_Rst at LATD3_bit;  // for writing to output pin always use latch
sfr sbit Net_Ethernet_28j60_CS  at LATD2_bit;  // for writing to output pin always use latch
sfr sbit Net_Ethernet_28j60_Rst_Direction at TRISD3_bit;
sfr sbit Net_Ethernet_28j60_CS_Direction  at TRISD2_bit;
// end ethernet NIC definitions
 
const code unsigned char httpHeader[] = "HTTP/1.1 200 OK\nConnection: close";  // HTTP header
const code unsigned char httpMimeTypeHTML[] = "\nContent-type: text/html\n\n";              // HTML MIME type
const code unsigned char httpImage[] = "HTTP/1.1 200 OK\nConnection: keep-alive\nContent-type: image/jpg\n\n";           // TEXT MIME type
unsigned char httpMethod[] = "GET /";
unsigned char httpRequ[] = "GET / HTTP/1.1";
 
 
unsigned char   myMacAddr[6] = "ENC28";   // my MAC address
unsigned char   myIpAddr[4]  = {0, 0, 0, 0};                   // my IP address: 0.0.0.0 => utilise le DHCP pour obtenir une IP
unsigned char   gwIpAddr[4]  = {192, 168,   1, 254};           // gateway (router) IP address
unsigned char   ipMask[4]    = {255, 255, 255,  0 };           // network mask (for example : 255.255.255.0)
unsigned char   dnsIpAddr[4] = {192, 168,   1, 254};           // DNS server IP address
 
unsigned char   getRequest[15];                                // HTTP request buffer
unsigned char   dyna[31] ;                                     // buffer for dynamic response
char led0status = 0;
 
int nb200ms = 0;
 
////////////////////////////////////////////////////////////////////////////////
// // User must set values of global variables in _Lib_NetEthEnc24j600_Defs.c file: !!!!!
/*
NUM_OF_SOCKET_28j60 = 7;     // Max number of socket We can open.
TCP_TX_SIZE_28j60 = 256;    // Size of Tx buffer in RAM.
MY_MSS_28j60 = 30;          // Our maximum segment size.
SYN_FIN_WAIT_28j60 = 1;      // Wait-time (in second) on remote SYN/FIN segment.
RETRANSMIT_WAIT_28j60 = 1;   // Wait-time (in second) on ACK which we expect.
*/
////////////////////////////////////////////////////////////////////////////////
 
char sendHTML_mark = 0;
SOCKET_28j60_Dsc *socketHTML;
unsigned int pos[10];
// Initialization of Timer1
unsigned int cnt;
 
void Net_Ethernet_28j60_UserTCP(SOCKET_28j60_Dsc *socket) {
  unsigned int    len;
  char content_length[32];
  asm CLRWDT;
  
  // I listen only to web request on port 80 for web server
 
  if(socket->destPort != 80) return ;
  // get 10 first bytes only of the request, the rest does not matter here
  for(len = 0; len < 10; len++){
    getRequest[len] = Net_Ethernet_28j60_getByte();
    }
  getRequest[len] = 0;
 
  // only GET method is supported here
  if(memcmp(getRequest, httpMethod, 5)&&(socket->state != 3)){
    return;
    }
 
  if(memcmp(getRequest, httpRequ, 9)==0){
    sendHTML_mark = 1;
    socketHTML = socket;
  }
 
 
  //............................................................................
  // Send html page.
  if((sendHTML_mark == 1)&&(socketHTML == socket)) {
    if(pos[socket->ID]==0) {
      LATD.F1 = 1;
      // Send HTTP header.
      sprintf(content_length, "Content-Length: %d", strlen(html_code));
      Net_Ethernet_28j60_putConstStringTCP(httpHeader, socket);
      Net_Ethernet_28j60_putStringTCP(content_length, socket);
      Net_Ethernet_28j60_putConstStringTCP(httpMimeTypeHTML, socket);
      Net_Ethernet_28j60_putConstStringTCP("<script>\n", socket);
      sprintf(dyna, "var kimoTemp=%2.1f\n",getTempKimo(KIMO_TEMP));
      Net_Ethernet_28j60_putStringTCP(dyna, socket);
      sprintf(dyna, "var kimoHygro=%2.1f\n",getHygroKimo(KIMO_HYGRO));
      Net_Ethernet_28j60_putStringTCP(dyna, socket);
      Net_Ethernet_28j60_putConstStringTCP("</script>\n", socket);
    }
    while(pos[socket->ID] < strlen(html_code)) {
      asm CLRWDT;
      if(Net_Ethernet_28j60_putByteTCP(html_code[pos[socket->ID]++], socket) == 0) {
        pos[socket->ID]--;
        break;
      }
    }
    if( Net_Ethernet_28j60_bufferEmptyTCP(socket) && (pos[socket->ID] >= strlen(html_code)) ) {
      Net_Ethernet_28j60_disconnectTCP(socket);
      LATD.F1 = 0;
      sendHTML_mark = 0;
      sendDATA_mark = 0;
      pos[socket->ID] = 0;
    }
  }
}
 
////////////////////////////////////////////////////////////////////////////////
 
int ReadSampleADC (char channel)
{
      /* Fonction de lecture des voies Analogiques */
      /* Les fonctions de MikroC ne semble pas s'accomoder des entrées différentielles */
      ADCON0 = channel * 4;
      ADCON0.f0 = 1;
      ADCON0.f1 = 1;
      while(ADCON0.f1 == 1);
      ADCON0.f0 = 0;
      
      return (ADRESH*256 + ADRESL)%4096;
}
 
unsigned int    Net_Ethernet_28j60_UserUDP(UDP_28j60_Dsc *udpDsc) {
 
  unsigned int    len = 0;                           // my reply length
 
  // reply is made of the remote host IP address in human readable format
  ByteToStr(udpDsc->remoteIP[0], dyna);                // first IP address byte
  dyna[3] = '.';
  ByteToStr(udpDsc->remoteIP[1], dyna + 4);            // second
  dyna[7] = '.';
  ByteToStr(udpDsc->remoteIP[2], dyna + 8);            // third
  dyna[11] = '.';
  ByteToStr(udpDsc->remoteIP[3], dyna + 12);           // fourth
 
  dyna[15] = ':';                                // add separator
 
  // then remote host port number
  WordToStr(udpDsc->remotePort, dyna + 16);
  dyna[21] = '[';
  WordToStr(udpDsc->destPort, dyna + 22);
  dyna[27] = ']';
  dyna[28] = 0;
 
  // the total length of the request is the length of the dynamic string plus the text of the request
  len = 28 + udpDsc->dataLength;
 
  // puts the dynamic string into the transmit buffer
  Net_Ethernet_28j60_putBytes(dyna, 28);
 
  // then puts the request string converted into upper char into the transmit buffer
 
  while(udpDsc->dataLength--)
          {
          Net_Ethernet_28j60_putByte(toupper(Net_Ethernet_28j60_getByte()));
          }
  return(len);
}
 
void interrupt (void)
{
     if (INTCON.T0IF == 1)
     {
        TMR0H = TMR0_PRE / 256;
        TMR0L = TMR0_PRE % 256;
 
        nb200ms++;
 
        if (nb200ms%5 == 0)
        {
           nb200ms = 0;
           Net_Ethernet_28j60_UserTimerSec ++;
        }
 
 
        if(led0Status == 0)
        {
            LATD.f0 = 0;
        }
        else if(led0Status == 1)
        {
            LATD.f0 = 1;
        }
        else if(led0Status == 2)
        {
            LATD.f0 = !LATD.f0;
        }
 
        INTCON.T0IF = 0;
     }
 
}
 
void MCUInit() {
        ADCON1 = 0;
        ADCON2 = 0b10101010;
        ANCON0 = 0xff;
 
        CM1CON = 0;
        CM2CON = 0;
 
        CVRCON = 0;
 
        PORTA = 0 ;
        TRISA = 0xff ;          // set PORTA as input for ADC
 
        PORTB = 0 ;
        TRISB = 0xff ;          // set PORTB as input for buttons
 
        LATD  = 0 ;
        TRISD = 0 ;             // set PORTD as output
 
        INTCON.GIE = 1;
        T0CON = 0b10000110;
        TMR0H = TMR0_PRE / 256;
        TMR0L = TMR0_PRE % 256;
        INTCON.T0IE = 1;
}
 
void main() {
        char useDHCP = 0;
        int i = 0;
        
        MCUInit();
 
        for(i = 0; i < NUM_OF_SOCKET_28j60; i++)
          pos[i] = 0;
 
        Net_Ethernet_28j60_stackInitTCP();
 
        SPI1_Init();
        SPI_Rd_Ptr = SPI1_Read;
 
        Net_Ethernet_28j60_Init(myMacAddr, myIpAddr, 1); // init ethernet board
        if(Net_Ethernet_28j60_getIpAddress()[0] == 0) useDHCP = 1;
        LATD.f1 = 0;
        led0Status = 2;
        
        asm CLRWDT;
 
        if(useDHCP == 1)
        {
            while(Net_Ethernet_28j60_initDHCP(10) == 0) // try to get one from DHCP until it works
            {
              Net_Ethernet_28j60_Init(myMacAddr, myIpAddr, 1);
              asm CLRWDT;
            }
 
            memcpy(myIpAddr,  Net_Ethernet_28j60_getIpAddress(),    4) ; // get assigned IP address
            memcpy(ipMask,    Net_Ethernet_28j60_getIpMask(),       4) ; // get assigned IP mask
            memcpy(gwIpAddr,  Net_Ethernet_28j60_getGwIpAddress(),  4) ; // get assigned gateway IP address
            memcpy(dnsIpAddr, Net_Ethernet_28j60_getDnsIpAddress(), 4) ; // get assigned dns IP address
 
        }
        else
        {
            Net_Ethernet_28j60_confNetwork(ipMask, gwIpAddr, dnsIpAddr) ; // use configured IP address
        }
 
        led0Status = 1;
        
        
        while(1) {
          //  Process incoming Ethernet packets
          Net_Ethernet_28j60_doPacket();
          
          asm CLRWDT;
          
          for(i = 0; i < NUM_OF_SOCKET_28j60; i++) {
           if(socket_28j60[i].open == 0)
             pos[i] = 0;
          }
          
          if(Net_Ethernet_28j60_doDHCPLeaseTime()) Net_Ethernet_28j60_renewDHCP(5); // it's time to renew the IP address lease, with 5 secs for a reply
 
        }
}

Les actions à effectuer dans l’ordre:

1. Définir les paramètres réseau:
   • Adresse IP
   • Adresse passerelle
   • Masque de réseau
2. Initialiser le module SPI
3. Initialiser le module Ethernet
4. Configurer le réseau (ou demander une IP par DHCP)
5. Définir les deux fonctions User_UDP et User_TCP qui sont appelées pour chaque requête reçue ou envoyée
6. Appeler la fonction doPacket() dans la boucle principale

Et voilà, vous êtes prêt à créer un mini serveur web basse consommation.