Installer l’IDE Arduino 1.5 sous Ubuntu 13.10

Je reprends mon article prĂ©cĂ©dent sur l’installation de l’IDE Arduino sous Ubuntu, mais cette fois on va installer la version qui est encore en bĂ©ta : Arduino 1.5 et sous Ubuntu 13.10. Nous allons toujours connecter une carte Arduino UNO via le cable USB.

L’IDE 1.5 ajoute le support de nouvelles architectures. Dans mon cas, cela devrait m’aider Ă  essayer de programmer directement la partie arduino de ma nouvelle carte Udoo. Cette carte est une sacrĂ©e bestiole : un raspberry PI et une arduino due en une seule carte. Mais j’en parlerai une autre fois.

On va donc tout refaire comme la fois précédente
 ou presque.

Étape 1, vĂ©rifier la prĂ©sence de Java

Ouvrir un terminal et taper un classique :

~$ java -version
java version "1.7.0_51"
OpenJDK Runtime Environment (IcedTea 2.4.4) (7u51-2.4.4-0ubuntu0.13.10.1)
OpenJDK 64-Bit Server VM (build 24.45-b08, mixed mode)

Tout est donc parfait, sinon il faut installer un OpenJDK 6 ou 7 (avec un “aptitude install openjdk-7-jdk” par exemple).

Étape 2,  installer les dĂ©pendances pour l’IDE

Dans le tutoriel prĂ©cĂ©dent, j’indiquais qu’il fallait installer les dĂ©pendances suivantes : gcc-avr et avr-libc. Cependant, il semble que cela ne soit plus nĂ©cessaire depuis la version 1.0.1 de l’IDE arduino car il y a une version packagĂ©e avec l’IDE. Je n’ai donc pas rĂ©alisĂ© cette Ă©tape et je confirme : cela fonctionne trĂšs bien sans.

Étape 3, ajouter l’utilisateur au group dialout

Pour pouvoir connecter la carte arduino au port USB de l’ordinateur et pour pouvoir communiquer avec, il faut que l’utilisateur qui va lancer l’IDE appartienne au groupe dialout. En considĂ©rant que l’utilisateur s’appelle marc :

~$ sudo usermod -aG dialout marc

Note : le nouveau groupe n’est pas affectĂ© Ă  la session courante. Vous pouvez tester une commande id ou groups dans un terminal. Pour que cela prenne effet, il faut soit redĂ©marrer la session utilisateur, soit faire un su - marc (remplacez marc par votre utilisateur bien entendu) dans un terminal et lancer l’IDE depuis ce terminal.

Si vous n’ajoutez pas l’utilisateur au groupe dialout — ou si l’affectation n’est pas prise en compte car vous n’avez pas redĂ©marrĂ© votre session — vous aurez ce genre de message d’erreur lorsque vous voudrez charger un sketch sur l’arduino :

avrdude: ser_open(): can't open device "/dev/ttyACM0": Permission denied
ioctl("TIOCMGET"): Inappropriate ioctl for device

Mais cela ne devrait pas vous arriver, car je vous ai bien prĂ©venu quand mĂȘme, non ?

Étape 4, installer l’IDE Arduino

Aller sur la page de tĂ©lĂ©chargement d’Arduino et rĂ©cupĂ©rer la derniĂšre version 1.5 qui correspond Ă  votre architecture, 32 bits ou 64 bits. Ici, ce sera la 64 bits. Vous devez savoir oĂč vous voulez l’installer. Chez moi ce sera dans $HOME/arduino.

~$ mkdir ~/arduino
~$ cd ~/Downloads
~/Downloads$ tar -C ~/arduino -xvzf arduino-1.5.6-r2-linux64.tgz
~/Downloads$ cd ~/arduino/arduino-1.5.6-r2/
~/arduino/arduino-1.5.6-r2$

Étape 5, connecter la carte et lancer l’IDE

Connecter la carte. Elle doit s’alimenter et les leds clignoter. Pour vĂ©rifier que le port correspondant est bien crĂ©Ă©, on peut faire un ls sur le tty correspondant :

~/arduino/arduino-1.5.6-r2$ ls -l /dev/ttyACM*
crw-rw---- 1 root dialout 166, 0 févr. 24 22:42 /dev/ttyACM0

On trouve bien le /dev/ttyACM0 et on voit bien qu'il appartient au groupe dialout.

Maintenant ouvrons l’IDE, depuis le dossier contenant l’extraction de l’archive, lancer la commande arduino :

~/arduino/arduino-1.5.6-r2$ ./arduino

Cela ouvre une fenĂȘtre comme celle de la capture suivante, oĂč l’on voit que l’IDE n’est pas configurĂ© sur le bon port de communication, il prend par dĂ©faut COM1 alors qu’on veut /dev/ttyACM0  :

L'ide Arduino 1.5.6 au premier lancementPour modifier le port, dans le menu “Tools > Serial Port” choisir celui qui vous intĂ©resse. Dans mon cas, ce sera /dev/ttyACM0.

Changement de port de communication pour l'arduinoCe paramĂ©trage sera conservĂ© au prochain dĂ©marrage de l’IDE.

Et voilĂ , vous pouvez maintenant charger des sketchs sur votre carte arduino
 Vous pouvez commencer par l’exemple blink fourni avec l’IDE, il fait clignoter la LED intĂ©grĂ©e Ă  la carte UNO :

Charger l'exemple "blink" intégré à l'IDE arduino

Puis le déployer directement :

Déployer le sketch "blink" sur l'arduino connectée

Bonne suite.

Micro benchmark de convertisseurs de tableaux de bytes vers représentation Hexa avec Java

Contexte

Il y a quelques temps maintenant je suis tombĂ© sur une offre d’emploi de la sociĂ©tĂ© ARCA Computing. Cette annonce est intĂ©ressante dans sa prĂ©sentation, car pour pouvoir candidater il fallait rĂ©soudre une petite Ă©nigme qui consistait Ă  rĂ©cupĂ©rer un projet hĂ©bergĂ© sur github, l’exĂ©cuter en remplissant quelques trous pour obtenir le contenu de l’annonce depuis le site web d’ARCA.

Bon, j’avoue, j’ai trichĂ© car j’ai juste rĂ©cupĂ©rĂ© le bout de code intĂ©ressant pour obtenir l’url, mis cela dans mon IDE pour obtenir le lien que j’ai ouvert directement dans un navigateur. Mais bref, lĂ  n’est pas le sujet


Ce qui a piquĂ© ma curiositĂ©, c’est la mĂ©thode convertToHex du petit exercice. J’avais souvenir d’avoir dĂ©jĂ  utilisĂ© ce genre de mĂ©thode, mais pas avec cette implĂ©mentation. Je me suis donc demandĂ© si elle Ă©tait plus intĂ©ressante que d’autres qu’on peut trouver ici et lĂ . AprĂšs une petite recherche, je suis tombĂ© sur un message de Stack Overflow qui proposait plusieurs implĂ©mentations : http://stackoverflow.com/questions/9655181/convert-from-byte-array-to-hex-string-in-java. Cela permettait d’avoir une bonne liste pour faire un petit comparatif Ă  l’arrache.

Le principe est simple :

  • Je fixe une limite de temps d’exĂ©cution : EXCLUSION_DELAY (en ms).
  • J’itĂšre sur les convertisseurs en les exĂ©cutants LOOPS fois sur une chaine d’entrĂ©e qui augmente Ă  chaque itĂ©ration. La chaine d’entrĂ©e est construite par rĂ©pĂ©tition d’une chaine de base autant de fois que le numĂ©ro d’itĂ©ration courante.
  • Lorsqu’un convertisseur dĂ©passe EXCLUSION_DELAY ms pour rĂ©aliser ses LOOPS conversions sur la chaine d’entrĂ©e, alors il est exclu de la suite du test et j’enregistre le numĂ©ro d’itĂ©ration oĂč il a Ă©chouĂ©.
  • Quand tous les convertisseurs sont finalement exclus, le test est terminĂ©. J’affiche donc le rĂ©sultat c’est Ă  dire le numĂ©ro d’itĂ©ration correspondant Ă  l’exclusion du convertisseur.

Ci-dessous les diffĂ©rentes implĂ©mentations que j’ai collectĂ©es. J’ai tout placĂ© dans une seule classe pour te faciliter la vie lecteur : si tu veux reproduire, pas besoin de tĂ©lĂ©charger une archive et tout le bataclan. CrĂ©er une nouvelle classe et copier/coller le code qui suit te permettra de tester rapidement et simplement de ton cĂŽtĂ©. Le “Converter 0” est l’implĂ©mentation extraite du code de l’annonce. Les “Converter 1“, “Converter 2“, “Converter 3“, “Converter 5“, “Converter 6“, “Converter 7” (il s’agit d’une lĂ©gĂšre variante du 6 qui n’apporte rien, j’aurai dĂ» le supprimer),  et “Converter 8” sont extraits de l’article de Stack Overflow ou des articles pointĂ©s. Le “Converter 4” est un mĂ©lange que j’ai rĂ©alisĂ© entre les “Converter 3” et “Converter 5

Le code

package net.ozim;

import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author <a href="mailto:dev@arliguy.net">Bruno ARLIGUY</a>
 */
public class HexaString {

    private interface Converter
    {
        public String execute(final byte[] data);
        public String getName();

        public boolean isExcluded();
        public boolean excluded();
    }

    private static abstract class AbstractConverter implements Converter {
        private int _count = 0;

        @Override
        public boolean isExcluded() {
            return _count > 2;
        }

        @Override
        public boolean excluded() {
            _count ++;

            return this.isExcluded();
        }
    }

    private static class Converter0 extends AbstractConverter {
        @Override
        public final String execute(final byte[] data) {
            final StringBuilder sb = new StringBuilder(2 * data.length);
            for (int i = 0; i < data.length; i++) {
                int halfbyte = (data[i] >>> 4) & 0x0F;
                int two_halfs = 0;
                do {
                    if ((0 <= halfbyte) && (halfbyte <= 9)) {
                        sb.append((char) ('0' + halfbyte));
                    }
                    else {
                        sb.append((char) ('a' + (halfbyte - 10)));
                    }
                    halfbyte = data[i] & 0x0F;
                } while (two_halfs++ < 1);
            }
            return sb.toString();
        }

        @Override
        public final String getName() {
            return "Converter 0";
        }
    }

    private static class Converter1 extends AbstractConverter {
        @Override
        public final String execute(final byte[] data) {
            final StringBuilder sb = new StringBuilder(2 * data.length);
            for(byte b: data) {
                sb.append(String.format("%02x", b&0xff));
            }
            return sb.toString();
        }

        @Override
        public final String getName() {
            return "Converter 1";
        }
    }

    private static class Converter2 extends AbstractConverter {
        @Override
        public final String execute(final byte[] data) {
            final StringBuilder sb = new StringBuilder(2 * data.length);
            for(byte b: data) {
                sb.append(Integer.toString( ( b & 0xff ) + 0x100, 16).substring( 1 ));
            }

            return sb.toString();
        }

        @Override
        public final String getName() {
            return "Converter 2";
        }
    }

    private static class Converter3 extends AbstractConverter {
        private static final String _chars = "0123456789abcdef";

        @Override
        public final String execute(final byte[] data) {
            final StringBuilder sb = new StringBuilder(2 * data.length);
            for (final byte b : data) {
                sb.append(_chars.charAt((b & 0xF0) >>> 4)).append(_chars.charAt((b & 0x0F)));
            }
            return sb.toString();
        }

        @Override
        public final String getName() {
            return "Converter 3";
        }
    }

    /**
     * Un mélange du converter3 et converter5
     */
    private static class Converter4 extends AbstractConverter {
        private static final String _chars = "0123456789abcdef";

        @Override
        public final String execute(final byte[] data) {
            final char[] result = new char[2 * data.length];
            int index = 0;

            for (final byte b : data) {
              result[index++] = _chars.charAt((b & 0xF0) >>> 4);
              result[index++] = _chars.charAt((b & 0x0F));
            }
            return new String(result);
        }

        @Override
        public final String getName() {
            return "Converter 4";
        }
    }

    private static class Converter5 extends AbstractConverter {
        private static final byte[] _chars = {
            (byte)'0', (byte)'1', (byte)'2', (byte)'3',
            (byte)'4', (byte)'5', (byte)'6', (byte)'7',
            (byte)'8', (byte)'9', (byte)'a', (byte)'b',
            (byte)'c', (byte)'d', (byte)'e', (byte)'f'
        };

        @Override
        public final String execute(final byte[] data) {
            final byte[] hex = new byte[2 * data.length];
            int index = 0;

            for (byte b : data) {
              final int v = b & 0xFF;
              hex[index++] = _chars[v >>> 4];
              hex[index++] = _chars[v & 0xF];
            }
            return new String(hex, StandardCharsets.US_ASCII);
        }

        @Override
        public final String getName() {
            return "Converter 5";
        }
    }

    private static class Converter6 extends AbstractConverter {
        private static final char[] _chars = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

        @Override
        public final String execute(final byte[] data) {
            final char[] hexChars = new char[data.length * 2];
            int v;
            for (int j = 0; j < data.length; j++) {
                v = data[j] & 0xFF;
                hexChars[j * 2] = _chars[v >>> 4];
                hexChars[j * 2 + 1] = _chars[v & 0x0F];
            }
            return new String(hexChars);
        }

        @Override
        public final String getName() {
            return "Converter 6";
        }
    }

    private static class Converter7 extends AbstractConverter {
        private static final String _chars = "0123456789abcdef";

        @Override
        public final String execute(final byte[] data) {
            final char[] hexChars = new char[data.length * 2];
            int v;
            for (int j = 0; j < data.length; j++) {
                v = data[j] & 0xFF;
                hexChars[j * 2] = _chars.charAt(v >>> 4);
                hexChars[j * 2 + 1] = _chars.charAt(v & 0x0F);
            }
            return new String(hexChars);
        }

        @Override
        public final String getName() {
            return "Converter 7";
        }
    }

    /**
     * Note : Using this will remove the leading zeros
     */
    private static class Converter8 extends AbstractConverter {
        @Override
        public final String execute(final byte[] data) {
            return new BigInteger(1, data).toString(16);
        }

        @Override
        public final String getName() {
            return "Converter 8";
        }
    }

    private static class ExclusionStep {
        private final Converter _converter;
        private final int       _step;

        public ExclusionStep(final Converter converter, final int step) {
            _converter = converter;
            _step = step;
        }

        @Override
        public String toString() {
            return String.format("%s at step %4d", _converter.getName(), _step);
        }
    }

    private static long doTest(final Converter c, final byte[] data, final int loops) {
        final long start = System.currentTimeMillis();

        for (int i = loops; i > 0; i--) {
            c.execute(data);
        }

        final long stop = System.currentTimeMillis();

        return (stop - start);
    }

    private final static int LOOPS = 40_000;
    private final static int EXCLUSION_DELAY = 300;

    public static void main(final String[] args) throws NoSuchAlgorithmException {
        final String base = "€€ ma base à mettre en hex string
 ";
        final List<Converter> converters = new ArrayList<>();

        converters.add(new Converter0());
        converters.add(new Converter1());
        converters.add(new Converter2());
        converters.add(new Converter3());
        converters.add(new Converter4());
        converters.add(new Converter5());
        converters.add(new Converter6());
        converters.add(new Converter7());
        converters.add(new Converter8());

        final byte[] validation = base.getBytes(StandardCharsets.UTF_8);

        for (Converter c : converters) {
            System.out.println(String.format("validation %s : %s", c.getName(), c.execute(validation)));
        }

        //warmup
        for (Converter c : converters) {
            doTest(c, validation, LOOPS);
        }

        boolean stop;
        int count = 0;
        final List<ExclusionStep> exclusions = new ArrayList<>();
        do {
            //create content to convert, longer at each loop
            final String current = new String(new char[++count]).replace("\0", base);
            final byte[] data = current.getBytes(StandardCharsets.UTF_8);

            System.out.println(String.format("step %d", count));

            int countExcluded = 0;
            for (Converter c : converters) {
                if (c.isExcluded()) {
                    countExcluded ++;
                }
                else {
                    final long duration = doTest(c, data, LOOPS);
                    if (duration > EXCLUSION_DELAY && c.excluded()) {
                        exclusions.add(new ExclusionStep(c, count));
                        System.out.println(String.format("Excluding %s", c.getName()));
                    }
                }
            }

            stop = countExcluded == converters.size();

        } while (! stop);

        for (ExclusionStep exclusion : exclusions) {
            System.out.println(exclusion.toString());
        }
    }
}

Le résultat

Voici ce que j’obtiens sur ma machine :

Converter 1 at step    3
Converter 8 at step    5
Converter 2 at step    6
Converter 3 at step   39
Converter 0 at step   42
Converter 5 at step   78
Converter 4 at step  111
Converter 7 at step  112
Converter 6 at step  113

NB : Attention, cela ne reprĂ©sente que le rĂ©sultat d’une exĂ©cution sur ma machine, il n’est pas garanti qu’ailleurs le rĂ©sultat soit identique.

Il ressort donc que le “Converter 0” est pile-poile au milieu de la liste. Que le “Converter 4” que j’ai fait en mixant le 3 et le 5 se comporte bien mieux qu’eux et qu’il Ă©gale mĂȘme le plus rapide qui est le “Converter 6” (le 7 Ă©tant une variante inutile).

Que conclure de ce petit test ? Que si vous avez besoin de faire plus de 40 000 conversions de tableaux de bytes en reprĂ©sentation hexa en moins de 300 ms sur de gros tableaux de bytes, alors il faut faire attention Ă  l’algo utilisĂ©. Sinon 
 Il y a peut ĂȘtre une meilleure façon de passer le temps :)

Et je me dis maintenant qu’il faudrait vraiment que j’essaye un framework de micro-benchmarks rĂ©alisĂ© par des gens plus compĂ©tents que moi pour voir ce que cela donne. J’ai notĂ© comme outils :

 

Edition collaborative de documents

Ensemble d’outils pour faire de l’Ă©dition collaborative de documents. Ce genre d’outils est parfait pour rĂ©aliser des documentations techniques oĂč il faut parfois intervenir Ă  plusieurs :

  • Etherpad, en licence Apache V2. Outil vraiment orientĂ© vers l’Ă©dition Ă  plusieurs : il est possible d’Ă©crire Ă  plusieurs sur le mĂȘme document et il y a une zone de discussion
  • Substance, en GPLv3. Outil pour faire plus un travail de rĂ©vision sur des documents : il est possible de commenter chaque paragraphe. Il permet d’avoir plusieurs sorties pour chaque document (ebook, page web, etc…). Se concentre plus sur la sĂ©mantique que sur l’apparence.
  • booktype, en AGPLv3. PrĂ©sentĂ© sur LinuxFR. OrientĂ© sur l’Ă©dition de livres. Permet de gĂ©nĂ©rer des formats e-book ou pour Ă©dition papier

Proxy socks via SSH pour Firefox

En milieu hostile — victime de censure ou plus bĂȘtement connectĂ© depuis un wifi public, un hĂŽtel, etc. — ou par volontĂ© de ne pas trop laisser les sites consultĂ©s vous suivre gĂ©ographiquement, il est prĂ©fĂ©rable de pouvoir utiliser un proxy. Dans le cas qui nous intĂ©resse, nous allons utiliser un tunnel SSH en tant que proxy SOCKS local pour le navigateur Mozilla Firefox. C’est super simple, il suffit d’avoir un compte SSH qui traĂźne. Pour la suite de l’exercice, ce compte SSH sera nommĂ© “tunnel“.

Ouvrir le tunnel

Pour cela, rien de plus simple, tu prends ta ligne de commande et tu tapes :

~$ ssh -2NfCT -D 8080 tunnel@example.org

Avec cette commande tu tu connectes en tant qu’utilisateur ‘tunnel‘ sur la machine ‘example.org‘ et le tunnel est accessible en local sur le port 8080. Pour vĂ©rifier que le tunnel soit bien lĂ  :

~$ netstat -apnt

(Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
[
]
tcp        0      0 127.0.0.1:3306          0.0.0.0:*               LISTEN      -               
tcp        0      0 127.0.0.1:8080          0.0.0.0:*               LISTEN      4464/ssh
[
]

Nous sommes content, il y a bien SSH sur le port 8080.

VĂ©rifier notre IP

Avant d’utiliser le proxy, nous allons vĂ©rifier notre adresse IP publique. Car une fois que le navigateur sera configurĂ© pour utiliser le proxy, elle devra ĂȘtre diffĂ©rente et correspondre Ă  l’adresse IP du serveur SSH utilisĂ©.

Il existe une foule de service pour dĂ©couvrir son adresse IP, mais je vais utiliser le mien : ipso.me. J’obtiens donc :

IPso.me découvre mon adresse IP - Avant proxy

Configurer Firefox pour utiliser le proxy SOCKS

Dans Firefox, ouvrir le menu “Edit > Preferences” et dans la fenĂȘtre de dialogue choisir l’onglet “Advanced” puis “Network” et finalement le bouton “Settings” :

Firefox Preferences

Choisir l’option “Manual proxy configuration”, cela active toute une sĂ©rie de champs de saisies. Dans le champ “SOCKS Host” y mettre “127.0.0.1”, notre adresse de loopback (Ă  adapter selon configuration) et dans le champ “Port” y mettre “8080” qui est le port d’Ă©coute du tunnel. Ensuite bien s’assurer que “SOCKS v5” est sĂ©lectionnĂ©, ainsi :

Connection Settings

Tu penses en avoir fini, mais non, il manque le dernier dĂ©tail qui tue : proxifier les requĂȘtes DNS. En effet, sur Firefox elles ne passent pas par dĂ©faut via le proxy SOCKS. Il parait que d’autres navigateurs le font. Mais pour Firefox, il faut lui forcer la main. Pour cela, ouvrir (1) “about:config” (saisir “about:config” dans la barre d’adresse) puis rechercher (2) l’entrĂ©e “network.proxy.socks_remote_dns” qui est Ă  “false” par dĂ©faut. Double cliquer (3) sur la ligne correspondante pour passer la valeur Ă  “true” :

about:config - Mozilla Firefox

 

VĂ©rifier

Tu retournes sur ton site préféré pour découvrir ton adresse IP et voilà :

IPso.me découvre mon adresse IP - AprÚs proxy

Tout est pour le mieux dans le meilleur des mondes.

Note : Il n’y a pas que Firefox dans la vie. Pour lancer Chromium en mode incognito et pour qu’il utilise le proxy SOCKS sans fuite DNS, d’aprĂšs cette page du site chromium.org il faut faire ainsi :

~$ chromium-browser --incognito --proxy-server="socks5://127.0.0.1:8080" --host-resolver-rules="MAP * 0.0.0.0"

 

Installer l’IDE Arduino sous Ubuntu 12.10

Note du 24/02/2014 : j’ai publiĂ© une mise-Ă -jour de cet article pour installer la version 1.5 bĂ©ta de l’IDE sous ubuntu 13.10.

Voici comment j’ai installĂ© l’IDE Arduino sous mon Ubuntu 12.10 sans passer par le package fourni avec la distribution : cela permet d’avoir la derniĂšre version car celle des dĂ©pĂŽts Ubuntu est plus ancienne que celle qu’on peut trouver sur le site Arduino.

Étape 1, vĂ©rifier la prĂ©sence de Java

Ouvrir un terminal et taper un classique :

~$ java -version
java version "1.7.0_09"
OpenJDK Runtime Environment (IcedTea7 2.3.4) (7u9-2.3.4-0ubuntu1.12.10.1)
OpenJDK 64-Bit Server VM (build 23.2-b09, mixed mode)

Tout est donc parfait, sinon il faut installer un OpenJDK 6 ou 7.

Étape 2,  installer les dĂ©pendances pour l’IDE

Les dépendances nécessaires en plus de Java sont les suivantes : gcc-avr et avr-libc. Leur installation va automatiquement ajouter une série de dépendances si elles ne sont pas déjà présentes, comme par exemple binutils-avr.

~$ sudo apt-get install gcc-avr avr-libc
[
]
Setting up binutils-avr (2.20.1-3) ...
Setting up gcc-avr (1:4.7.0-2) ...
Setting up avr-libc (1:1.8.0-2) ...

Tout s’est bien passĂ© jusqu’Ă  prĂ©sent.

Étape 3, ajouter l’utilisateur au group dialout

Pour pouvoir connecter la carte arduino au port USB de l’ordi et pour pouvoir communiquer avec, il faut que l’utilisateur qui va lancer l’ide appartienne au groupe dialout. En considĂ©rant que l’utilisateur s’appelle marc :

~$ sudo usermod -aG dialout marc

Étape 4, installer l’IDE Arduino

Aller sur la page de tĂ©lĂ©chargement d’Arduino et rĂ©cupĂ©rer la version qui correspond Ă  votre architecture, 32 bits ou 64 bits. Ici, ce sera la 64 bits. Vous devez savoir oĂč vous voulez l’installer. Chez moi ce sera dans $HOME/arduino.

~$ mkdir ~/arduino
~$ cd ~/Downloads
~/Downloads$ tar -C ~/arduino -xvzf arduino-1.0.3-linux64.tgz
~/Downloads$ cd ~/arduino/arduino-1.0.3/
~/arduino/arduino-1.0.3$

Étape 5, connecter la carte et lancer l’ide

Connecter la carte. Elle doit s’alimenter et les leds clignoter. Pour vĂ©rifier que le port correspondant est bien crĂ©Ă©, on peut faire un ls sur le tty correspondant :

~/arduino/arduino-1.0.3$ ls -l /dev/ttyACM*
crw-rw---- 1 root dialout 166, 0 févr. 12 22:45 /dev/ttyACM0

On trouve bien le /dev/ttyACM0.

Maintenant ouvrons l’IDE, depuis le dossier contenant l’extraction de l’archive, lancer la commande arduino :

~/arduino/arduino-1.0.3$ ./arduino

Cela ouvre une fenĂȘtre comme celle de la capture suivante, oĂč l’on voit que l’IDE n’est pas configurĂ© sur le bon port de communication, il prend par dĂ©faut COM1 alors qu’on veut /dev/ttyACM0  :

L'ide Arduino 1.0.3 au premier lancement

Pour modifier le port, dans le menu “Tools > Serial Port” choisir celui qui vous intĂ©resse. Dans mon cas, ce sera /dev/ttyACM0.

Changement de port de communication pour l'arduino

Et voilà, vous pouvez maintenant uploader des sketchs sur votre carte arduino


Un montage fait en se basant du guide présent dans le Starter Kit d'Arduino
Un montage fait en se basant du guide prĂ©sent dans le Starter Kit d’Arduino

Bonne suite.