Qu’est ce qu’est Arduino?

Une plateforme de développement hard et soft, souple, bon marché, aux sources multiples, facile à mettre en oeuvre, bien documentée, bref l’environnement idéal pour débuter dans le domaine de l’embarqué (embedded in english). Vous désirez utiliser de l’électronique et de la microprogrammation? Piloter un moteur, activer un buzzer? afficher des informations, lire une température, une pression? C’est de prime abord passablement difficile.

Il faut se farcire des datasheet éprouvantes, souvent en anglais. Faire un schéma des composants qui tienne la route. Sortir le fer à souder, picots, circuit imprimé, ou pour le moins câbler (sans se tromper!) des chips et autres composants pas facile à appréhender, poser des connecteurs. Choisir une alimentation.

Ce n’est pas fini: il faut aussi trouver un environnement de développement: en assembleur (pas de chance! On se retappe des liste d’opcodes et on cherche les registres du processeur et leurs multiples finesses) en BASIC ou en C. Puis il faut se documenter comment produire le code exécutable et le charger dans la mémoire de la cible que vous aurez sélectionnée. Avec un peu de chance, on trouve des exemples de code qui résolvent notre problème: mais là encore, il faut adapter, voire fortement modifier le code pour que ce soit compatible avec notre montage.

Arduino standardise tout ça et le rend accessible rapidement: hard, soft, exemples Voyons comment.

La plateforme hardware

Commençons par voir ce qui se fait au point de vue du matériel. La carte processeur est faite autour du microcontrôleur Atmel AVR. La carte de base classique est la Arduino Uno.

On en trouve de nombreuses déclinaisons, dont celle mise au point par le Professeur Nicoud, la Diduino (http://didel.com) basée sur le modèle ATmega328, un modèle RISC de 8 bits à 20 MHz (voir: http://www.atmel.com/devices/ATMEGA328.aspx pour les détails). Car c’est possible de fabriquer soi-même une carte compatible Arduino: http://arduino.cc/en/Main/Policy. La carte Diduino possède un bloc d’expérimentation, elle est livrée avec un set de composants pour tester des montages.

Suivant le but du montage, on peut choisir une autre déclinaison du board CPU: le modèle Mega, Lyli Pad, le Nano, ou le Mini, voir d’autres dérivations de fabricants imaginatifs.

Des extensions, dénommées  »shield », peuvent être rapportées sur la version de base pour y ajouter, Bluetooth, Ethernet, Flash card, commande de moteurs. Bref un joli pannel d’interfaces possibles. Les modules d’origine des différentes versions de l’Arduino sont fabriqués par la société italienne Smart Projects. Mais oui, les concepteurs d’Arduino sont italiens!

L’environnement soft

Installation

L’environnement de développement se charge depuis le site officiel: http://arduino.cc/en/Main/Software. C’est assez lourd: 70 Mb, et une fois décomprimé, c’est 232 Mb. Par contre vous pouvez déplacer le répertoire arduino-1.0 ou bon vous semble, voire sur une clef USB: il se lancera sans problème. Comme il est écrit en Java, il tourne sur les trois OS phares: Windows (32 et 64 bits), Linux, Mac. Il est basé sur Processing et contient le compilateur avr-gcc, ainsi qu’une panoplie de softs Open Source.

Une fois arduino.exe lancé, le développement proprement dit se fait dans des modules appelés « sketch ». Voici à quoi cela ressemble.

Sketch

La barre des menus est suivie d’icônes, permettant de faire son développement: valider le code, le charger, créer un nouveau Sketch, charger et enregistrer. Le source, en C/C++ est introduit dans la fenêtre texte. La partie code montre une syntaxe à peine colorée: les mots-clefs reconnus sont en brun. Le Sketch est sauvé dans un répertoire du nom du projet, et le fichier de même nom prend l’extension « .ino »; c’est en fait le fichier source à l’identique, sans fioriture, éditable et copiable p. exemple avec Notepad++.

Une fenêtre inférieure montre le résultat des différentes commandes: ici celui d’une compilation réussie. Des erreurs seraient écrites en rouge.

Les paramètres de transfert sont réglés par le choix de la cible, et le port série à utiliser. Ici: Atmega328 et COM11.

De manière générale, le programme est constitué d’une fonction d’initialisation setup(), et d’une boucle infinie loop(). Elles constituent une surcouche du C qui habituellement appelle le programme principal par la fonction main().

Vous trouverez une introduction pratique plus détaillée sur le site de notre HB9 préféré, Michel Vonlanthen, ici: http://www.von-info.ch/hb9afo/arduino/main.htm

Parmi un foultitude d’exemples de programmation, la base consensuelle et universelle est toujours le clignotement d’une LED, alimentée par une patte de sortie du CPU via une résistance de quelques kilo-Ohms. Le programme consiste à : positionner la sortie à l’état haut, attendre, positionner à l’état bas, attendre, et boucler ad aeternam. Ensuite, on peut compliquer à souhait en testant un bouton, en attendant une valeur, en écrivant sur le port sériel, en pilotant un moteur, etc, etc!

Or l’exemple ci-dessus montre l’utilisation d’une technique fort avancée: l’utilisation de l’interruption. On en discute plus bas.

Chargement et éxécution

Le programme est fait, la cible connue (type de circuit Arduino ATmega328) , il faut maintenant charger le programme. Diduino (et d’autres…) proposent la connexion USB. Celle-ci, non seulement alimente la carte – tant qu’on ne lui ajoute pas de moteurs ou de relais qui demande de la puissance – ouvre une connexion série. Autant sous Windows que Mac, il faut installer le pilote adéquat. La version la plus simple est de laisser Windows « chercher le pilote adéquat »; sinon, il faut le faire à la main. Les pilotes sont dans le répertoire: \arduino-1.0\drivers\. Ou directement du fabricant,  FTDI, a disposition ici: http://www.ftdichip.com/Drivers/VCP.htm.

Un fois la fiche USB connectée, le pilote Windows se montre: Start -> Périphérique et imprimantes -> Non spécifié(e)s

Malgré l’installation réussie du pilote, du paramètre Tools -> Serial Port (et le choix du bon n° de seriel), il se peut que ça ne fonctionne pas. A titre indicatif, sur 2 PC différents j’ai expérimenté:

- Pas de recherche automatique de Windows 7: il m’a fallut indiquer où se situe le pilote sur le bon répertoire, et l’installer. Tout a fonctionné parfaitement

- Recherche automatique: Windows recherche le pilote, l’installe.

Par contre à l’utilisation, des soucis de menu: il met 18 secondes pour se développer! La programmation patine aussi, avec le message sibyllin suivant: avrdude: stk500_getsync(): not in sync: resp=0×00. Un driver corrigé s’adresse à ce problème, ici: http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1237179908. Il appert que la DLL qui scrute les ports série les énumère à tout coup et attend leur time-out… Suite au remplacement de la DLL : rxtxSerial.dll, tout fonctionne bien sur mes deux PCs.

Il faut donc persévérer et rechercher sur le WEB une solution.

La souplesse et l’exemple

La force de l’ensemble Arduino est d’offrir d’une part un matériel défini, puisque même les sources d’autres constructeurs « collent » aux spécifications des originaux; en offrant bien entendu plus de ports, ou un processeur plus puissant. Et d’autre part, un ensemble logiciel préparé et épuré pour programmer la cible. Le choix du C/C++ est à mon avis fort judicieux: ce langage permet de compiler du code très efficace et proche de la machine.

NDA: je suis un peu plus dubitatif avec le C++. Vu la taille mémoire à disposition, on ne voit pas trop comment des instanciations d’objets ou des templates un peu compliquées auraient leur place. Mais comme à l’heure d’écrire ces lignes je n’ai que pratiqué des petits exercices, cela pourrait changer à l’avenir.

Il vaut la peine de se pencher un peu plus sur ce programme d’interruption, pour montrer la souplesse et la puissance d’abstraction des librairies Arduino. Comment est gérée une interruption? Pour répondre à une requête d’interruption, le processeur devra (source Wikipédia) :

• préserver le contexte d’exécution du programme en cours afin de pouvoir, à terme, en reprendre l’exécution ;
• lire en mémoire l’emplacement du programme destiné à gérer l’événement particulier (appelé gestionnaire d’interruption ou routine de gestion d’interruption), pré-établi lors de la prise en charge, par l’ordinateur, de l’ensemble spécialisé ici, par la routine start();
• exécuter la routine, court programme grâce auquel le processeur interagira avec l’ensemble spécialisé qui le sollicite afin de satisfaire ses attentes ;
• restaurer le contexte d’exécution du programme interrompu ; et enfin
• continuer à exécuter ce dernier.

On le voit, ce mécanisme est aussi complexe que délicat à mettre en oeuvre. Eh bien, avec Arduino, on initialise l’interruption en une fonction de 3 paramètres: attachInterrupt(0, irq_func, FALLING); . Ceci a pour effet de lier lorsque l’interruption hardware n°0 est déclenchée, d’appeler la routine d’interruption ici réalisée par la fonction « irq_func() », sur un flanc descendant. Les autres possibilités étant: flanc montant, état haut, état bas. Le fameux flanc descendant est activé lorque la LED rouge s’eteint, car on aura pris soin de relier cette sortie n°13 sur la patte n°2 qui est effectivement l’entrée d’interruption 0.

La fonction d’interruption se contente d’inverser l’état de la LED jaune, ce qui fait qu’elle clignote à une fréquence de moitié de la LED rouge. Avec l’environnement de développement viennent de nombreux exemples didactiques de programmation : \arduino-1.0\examples\, et bien sûr sur le site officiel: http://arduino.cc/en/Tutorial/HomePage.

Les fonctions dédiées et librairies

Il est clair que le C pur ne suffit pas – a vrai dire, le C pur n’existe pas! Ce langage s’applique a quasi tous les CPU, du 8 bit au 64 bits (voir plus?) et un montage 8 bits n’a pas les mêmes possibilités qu’un système multicoeurs. Pour chaque implémentation, il y a des fonctions dédiées qui permettent d’utiliser toutes les finesses du système. Arduino a aussi les siennes, sur le WEB ici: « langage reference« , en local dans /arduino-1.0/reference/index.html.

On y trouve notamment les possibilités de positionner directement et efficacement une patte à 0 ou à 1, de la lire, par respectivement digitalWrite() et digitalRead(). Plus exotique, la fonction qui permet de moduler une largeur d’impulsion (PWM, Pulse Width Modulation) s’appelle analogWrite(), en décalage par rapport à analogRead(), qui fait elle fait une vraie conversion analogique -> numérique (A/D: Analog -> Digital). C’est bien sûr dépendant des possibilités du CPU.
Des librairies sont également à disposition http://arduino.cc/en/Reference/Libraries. Il s’agit des les importer pour pouvoir en utiliser les fonctions. Celles-ci d’adressent à du matériel (EEPROM, LCD, cartes SD) ou des protocoles souvent utilisés (Serie, Ethernet, SPI).

Du hard et du soft, un cours très complet

Le document ci-dessous est une large représentation de réalisations Arduino. Mais constitue aussi un cours complet de mise en oeuvre, qui explore toutes les facettes en partant de l’électronique, de la réalisation pratique avec des maquettes dessins, schémas. En français, s’il vous plaît.
http://fr.flossmanuals.net/_booki/arduino/arduino.pdf

Des fournisseurs

Pour débuter et tester, la carte Diduino, elle est idéale.

Les indications ci-dessous m’ont été communiquées par M. Frédéric Benninger, donc pas (encore) testées personnellement.

Le Seeeduino Starter Kit Standard[Shop.boxtec.ch] vise le même but, mais elle pourra par la suite être réutilisée dans un produit fini. Pour ceux qui visent une application dédiée, cela dépend de la taille du projet et du type d’alimentation envisagée. Par exemple en modélisme le Seeeduino Film est un must, seulement quelques grammes, elle est livrée avec une petite batterie et le régulateur de charge pour panneaux solaires est inclus.

Pour faire une application qui a besoin de gérer une horloge calendaire, par exemple à des fins d’ d’acquisition de données, le Seeeduino Stalker est parfait, il intègre une RTC et un emplacement pour carte micro SD.

Voici encore des châssis [www.sparkfun.com] pour les bricoleurs, sans oublier des boîtes [shop.boxtec.ch] pour mettre en valeur le fruit du travail fourni.

Des références

LE site de référence: Arduino.cc

Wikipédia: http://fr.wikipedia.org/wiki/Arduino

Liste de discussion (Suisse) : http://fr.groups.yahoo.com/group/arduino_suisse/

Installation et 1ère prise en main

L’environnement PyCharm, de Jetbrains (http://www.jetbrains.com/pycharm/) est prévu pour la programation, test, debug et déployement en Python. Le fichier téléchargé pour l’installation pèse env.80 MB. Elle se fait sans problème, pas besoin de redémarrer Windows. Avant de le lancer, il faut avoir un (ou plusieurs) interprèteur(s) Python installé(s). Dans mon cas, j’ai la version 2.7.2.

Au lancement, PyCharm vous demande lequel vous utilisez, afin de l’analyser et l’indexer. Ce qui prend pas mal de temps.

Si comme moi vous rangez vos projets Python dans un répertoire, il suffit d’indiquer à PyCharm avec lequel vous voulez travailler; il en fait un projet. Chaque fichier *.py du répertoire peut être démarré, Par contre, il faut le configurer en conséquence. Ci-dessous, le message: « Configure Python Interpreter », qui survient, la config étant accessible en tout temps via l’icône « clef à écrou » juste avant le « Help ».

Disposition

Les fenêtres sont assez parlantes par elles même: Projet, Structure, Favorites, mais précisons qu’on peut les développer par Alt + n° de la fenêtre dans le layout, qui lui même est configurable et modifiable. Les fenêtres peuvent être Pined, Docked, Split ou encore Floating. Un double clic sur un nom de fichier du projet l’ouvre dans l’éditeur. Évidemment en syntaxe colorée. La structure correspondante apparaît et peut être développée. L’élément est représenté par un symbole coloré. On a v: variable, C: classe ou m: fonction (méthode, selon la terminologie PyCharm); si le symbole est cliqué, le curseur est positionné à l’endroit adéquat dans le fichier source. Celui-ci est encodé en utf-8 par défaut, PyCharm gère aussi le format de lignes Mac ou Unix.

Toutefois, j’ai été surpris par un fichier de config contenant des lettres accentuées au format ANSI Windows-1252 (et non utf-8 comme indiqué ci-dessous), il affichait de vilains losanges avec ‘?’.

Dans l’implémentation du code nécessaire au projet « barrette écologique », j’ai quelque peu séché sur le problème du suivi de la table de commutation. Celle-ci contient des données non-triée de temps, de jour(s) de la semaine et de la commutation à appliquer.

Comment trouver à coup sûr la dernière commutation et la prochaine à venir? Une fonction de différence de temps est nécessaire et rend un delta:

delta = ((int) prtc_line->hour - (int) DB_SystemClock.Time.hh) * 60 +
(int) prtc_line->minute - (int) DB_SystemClock.Time.mm;

Petit piège en langage C, les bytes à transformer en int, sinon-> écrêtage à 255. Ensuite, nous parcourons régulièrement toutes les lignes du tableau de commutation.  Ainsi la valeur obsolète sera mise à jour. Celle-ci sera remplacée au fil des scan, si une ligne plus proche existe dans la table, parcourue de 0 à n.

Pour résoudre ce problème, je me suis contenté d’une fonction qui ne traite que 24 heures, laissant à plus tard son complément pour traiter des semaines. Le tableau ci-dessous montre la simplicité du raisonnement pour 24H:

• Le plus grand delta négatif est celui de la dernière commutation à 11h – l2;
• Le plus petit delta positif, la prochaine commutation 13h – l3.

Sur une semaine, ça ne fonctionne plus! En effet, admettons que nous sommes lundi (jour=1) et que les commutations sont seulement sur dimanche, jour=7? En admettant que notre fonction « delta » ajoute 24*60 par jour, il apparaît que la prochaine commutation est la première de dimanche, et la commutation en cours est la dernière de dimanche!! Tous des nombres positifs!! Notre fonction va donc trouver

• Le plus grand delta (mais pas négatif) sera celui de la dernière commutation à 14h – l4;
• Le plus petit delta positif, la prochaine commutation 10h – l1.

Faut-il une logique « intraday », travaillant avec +/- et une autre pour les jours à distance?

Commutation	l1	l2	time	l3	l4
heure	10h00	11h00	’12:10	13h00	14h00
Delta	-130	-70	delta	+50	+110
Delta corrigé 1 semaine	+9950	+10010	-	+50	+110

La solution est la suivante: lors de la recherche et comparaison, pour éviter les problèmes des jours répartis sur une semaine, on ajoute une correction de 7 jours * 24 heures * 60 minutes au temps de commutation de la ligne lue s’il est inférieur a 0. ce calcul tient compte du fait que les écarts sont cycliques sur une semaine de 7 jours. De ce fait, le test de comparaison de temps se fait toujours sur des nombres strictement positifs, et fonctionne pour le jour courant et … les autres de la semaine.

Grâce à Code::Blocks, j’ai pu tester et valider mes fonctions efficacement, car modifier + charger le binaire dans le module PIC est bien long… voir: http://microclub.ch/2009/11/23/barrette-ecologique-suivi

Yves Masur

Les version de Windows précédentes utilisaient NTBACKUP pour copier des fichiers sur une sauvegarde. Une optimisation plus user friendly est implémentée sous W7. Mais comment se passe une restauration depuis zéro? Il faut un certain courage pour s’y lancer. Ou avoir confiance dans le système…

Comme ma version (RC2) arrive au terme de sa période – plus que 10 jours!! – c’est le bon moment pour s’y mettre. Bien entendu, je lance un dernier backup sur un disque de 500 Go connecté par USB, avant d’insérer le DVD de la version finale de W7 et redémarrer le PC. Comme je n’ai plus utilisé Vista depuis, je me propose de formater et installer sur cette partition. Que j’efface (tiens, j’ai plus de place tout à coup!). Et que je formatte, et sélectionne comme LA partition W7 (tiens, W7 demande 100 Mo pour y faire des sauvegardes).

Suit la série d’installation et redémarrage… la clef… le WLAN, la clef WPA… l’utilisateur… le password… le clavier… la langue… la zone. Me voici devant un bureau vierge, avec une résolution minable. Que je passe immédiatement en 1920 x 1200.

Restauration des fichiers: elle redonne tous les fichiers qui étaient dans le chemin C:\Users\(nom); pas de souci de ce côté. Si un fichier existe déjà, par exemple « desktop.ini » qui est un fichier caché, il pose la question et propose le même traitement pour la suite:

• ecraser par celui de la sauvegarde
• conserver
• remplacer et conserver un copie, au cas où

Evidemment, mon bureau n’a pas changé… Faut-il ré-installer tous les programmes? Essayons avant cela la…

Restauration du système: un avertissement m’indique que la récupération standard suffit pour la plupart des problèmes, sinon, il est possible de passer à la version avancée. Allons-y pour la standard. Après la restauration, le système me délogue et redémarre. Et après l’ouverture de session, je me retrouve devant un bureau pourvu d’icônes… standard. Je 2xclique dessus Total Commander, et contre toute attente, il se lance! Idem avec Code::Block, DOSBOX, TTermPro… jusqu’à SoundRescue, qui prétend ne pas être enregistré. Humm… Mon soupçon augmente lorque je regarde C:\Program Files, qui est quasi vide; il se vérifie lorsque la dé-installation de programme est vide, et se confirme lorsque je vérifie le lien de VNC: « D:\Program Files\RealVNC\VNC4\vncviewer.exe ». Ils pointent sur la partition D:, qui – toujours présente – est l’ancienne de W7!!

En outre, tous les programmes installés « à la main » dans la racine de C: n’y sont pas non plus. Je les ai repris de la partition D:. En guise de conclusion, le backup de W7 sauvegarde vos données de profil, mais guère plus.

Yves Masur

Or donc Vista et W7 supportent les liens sur les arborescences NTFS. Jusqu’ou? voici quelques expériences, faites sur un dique à 2 partitions: C: et D: qui ont Vista et W7 64 bits. Le système démarré obtient le C:, l’autre le D: et respectivement. Un seul répertoire \temp est suffisant; on peut le créer ainsi:

C:\>mklink /J temp d:\temp
Jonction créée pour temp <<===>> d:\temp

Ainsi l’on voit c:\temp et D:\temp, mais le « vrai » est sur D:, est c’est transparent:

C:\temp>dir
 Le volume dans le lecteur C s'appelle Vista
 Le numéro de série du volume est 4C45-D48C
 Répertoire de C:\temp
20.06.2009  11:02    <REP>          .
20.06.2009  11:02    <REP>          ..
11.06.2009  10:05           131'906 cmd-c.pdf
06.06.2009  06:25               403 driverinst.log

Pour la petite histoire, le disque C: avait déjà un lien sur c:\temp, nommé tmp. Ce dernier était un moment orphelin, vu que le répertoire cible « C:\temp » était détruit en vue de le remplacer par le lien sur son alter-ego de D:\temp. Et maintenant, si je liste C:\tmp, le contenu est automatiquement celui de D:\temp !

Qui dit mieux? Un programme, pour voir. La tricherie est assez monstrueuse: j’envisage de lancer non moins que Firefox de W7 (en 32 bits, donc dans le répertoire x86) par la session Vista. Un premier essai ne fonctianne pas, car des résidus sont restés dans « Programm Files » de Vista:

C:\Program Files>mklink /J "Mozilla Firefox" "d:\Program Files (x86)\Mozilla Firefox"
Impossible de créer un fichier déjà existant.

La destruction du répertoire soigne le mal; et on reprend:

C:\Program Files>mklink /J "Mozilla Firefox" "d:\Program Files (x86)\Mozilla Firefox"
Jonction créée pour Mozilla Firefox <<===>> d:\Program Files (x86)\Mozilla Firefox

Ensuite, je crée le raccourci sur l’EXE mappé dans le lien. Celui-ci possède le répertoire: « C:\Program Files\Mozilla Firefox\firefox.exe ». Il vise dont à travers le lien! Et ça fonctionne pile-poil.

En conclusion, on peut grâce aux liens arranger  des configurations sans ré-installer, installer à double ou copier les mêmes données. Prudence avec les backup…

Yves Masur

Michel Vonlanthen a (enfin!) publié ses photos lors du festival de robotique 2008 de l’EPFL. Elles sont visibles en commençant ici: http://www.hb9afo.ch/blog/20080419_epfl_festival%20robotique/robotique.gif

Et ensuite, le chargement de la suivante se fait en diaporama. Elle sont représentatives de l’ensemble de la manifestation, qui avait eu un succès mérité. Merci Michel pour ces vues!  Et un conseil en passant: utilise plutôt Jalbum pour créer tes albums WEB… il fait tout: imagettes, réduction, mise en page, navigation, skin, etc, etc!

Yves Masur

(texte et image de Daniel Roux, repris de la page « Simulateur de Dauphin » sur Epsitec.ch dans le but de faire de la pub pour cet excellent travail didactique)

En 1977, le professeur Jean-Daniel Nicoud crée le Dauphin, un génial petit ordinateur livré en kit, qu’il fallait construire soi-même. Cette sympathique machine a rencontré un grand succès en Suisse romande, permettant à de nombreux passionnés de s’initier à cette nouvelle discipline.

Aujourd’hui les PC sont développés par de grandes équipes d’ingénieurs, mais les principes de base sont restés les mêmes. Pour fêter ses 30 ans, la société EPSITEC a développé un ordinateur Dauphin virtuel, accompagné d’un excellent manuel didactique. Tout ceci est gracieusement mis à votre disposition sur la page « Simulateur de Dauphin » sur Epsitec.ch

Avec ce simulateur, vous vous trouvez face à un ordinateur rudimentaire, vierge de tout logiciel, qui ne sait strictement rien faire, exactement comme à l’époque des pionniers de l’informatique. C’est vous qui lui donnez toutes les instructions qu’il doit exécuter. Même les tâches les plus simples telles qu’afficher la valeur correspondant à la touche pressée doivent être programmées. Vous acquerrez ainsi les bases de la programmation en « langage machine », une chose presque totalement oubliée de nos jours.

(document publié dans le Mi-Chronique No 50 de Décembre 1995 et retouvé en mai 2008 )

Maintenant j’en suis sur, vous n’écrivez pas d’articles parce que vous avez pitié de votre rédacteur. Vous avez réalisé que chaque texte qui m’était envoyé nécessitait de longues minutes de fastidieuses-zé-répétitives opérations pour ajuster les belles colonnes que vous voyez là, faire les petits points bien alignés dans les-zé-numérations etc etc.

Et bien figurez-vous que c’est TOTOmatique, ou presque! Et que même, pour pondre la version WWW de votre journal d’informatique favori (rappel : il s’appelle Mi-Chronique), et bien il ne faut que quelques secondes. Comment c’est-y pas possible ? Grâce à un truc qui existe depuis Word 1.0 (plus ou moins Perfect, certainement) et qui s’appelle le Style!

Apparemment, y’en a qui savent pas s’en servir, ce qui fait que s’ils sont timides en plus, ils n’écrivent pas et que si ils sont gonflés, et bien je dois effectivement passer de longues minutes de fastidieuses-zé-répétitives opérations pour ajuster les belles colonnes que vous voyez là, faire les petits points bien alignés dans les-zé-numérations etc etc. (merci à notre sponsor CUT & PASTE & Co)

Alors je m’en vais vous faire un petit cours sur comment écrire des textes pour les filer à des copains qui devront les mettre en page avec un autre traitement de texte ou une autre machine C’est 3.33 fois plus simple que le judaïsme parce qu’il n’y a que trois lois:

1. Au kilomètre tu taperas, Point de fantaisie ne feras,
2. Standard tu sauveras. (au nom du TXT, du RTF et de l’HTML, Amen)

Après, il faut qu’un érudit (moi) explique ces directives au bas peuple (vous) de façon à ce que le bas peuple comprenne pourquoi il mérite l’enfer, la damnation et les coups de bâton de l’érudit:

La première loi dit qu’il ne faut pas espérer que le texte sera imprimé avec la même fonte et la même largeur de papier que celles utilisées pour l’éditer. Il faut donc imaginer que les retours de lignes se feront n’importe où dans le paragraphe. Donc la touche “return” sert à terminer un paragraphe, pas une ligne!

La seconde loi dit qu’il faut pas trop essayer de faire joli à coups de tabulateurs, ou pire de ribambelles d’espaces pour aligner des trucs, de tirets pour faire des soulignés et des machins comme ça car y faudra tout enlever à la main pour que ça ait un look uniforme dans une présentation. Dans un beau texte “portable”, il n’y a pas non plus de multiples sauts de lignes pour séparer des sections du document.

Alors comment transmettre la structure d’un texte? La troisième loi est là pour ça. N’envoyez que des fichiers en TXT (texte pur) ou RTF (Rich Text File) ou encore en HTML (le format des documents WWW sur Internet), qui sont des formats texte avec des informations sur la présentation codées en texte elles aussi. Ainsi, à l’aide de simples appels aux fonctions “recherche & remplace” de votre traitement de textes favori, le récepteur pourra mettre en forme le document. Avec des outils à la GREP, ceci devient même très automatisable, voire totalement automatique avec certains éditeurs/traitement de textes macro-isables, parmi lesquels, Word.

C’est ainsi par exemple que votre bien aimé éditeur en chef s’est mis en tête de créer votre bô journal en ne faisant qu’importer des articles stockés dans des fichiers séparés, ce qui facilite grandement ce dont je vais vous causer dans le prochain article (suspense). Il est alors vachement facile de modifier la mise en page de l’opuscule tout en conservant substantifiquement la moëlle des articles. Alors, siou plaît, vous qui n’écrivez pas d’article, ne les écrivez surtout pas en vous fatiguant à faire des mises en page. Votre Redactor est là pour ça, et vous le payez cher…

Goulu el Redactor