Je réalise mon rêve d’enfance en ce moment, la réalisation d’un robot de A à Z. Je regrette de finir mes études à l’UTT dans 2 mois, ça commence à devenir vraiment passionnant ! Donc en fait je travaille sur un robot wifi commandé par manette de wii. J’ai réussi à caser ça comme projet dans mon cursus, au lieu de faire un cours bouche trou pour finir ma 5eme année, bah je me suis lancé avec un autre étudiant dans le développement d’un chti robot Il ne s’agit pour l’instant que de notre premier prototype, comme vous pouvez le voir il n’est pas entièrement autonome. On doit encore travailler sur l’alimentation du système embarqué (Carte Fox), du routeur wifi et des servomoteurs. Pour l’instant on a des gros fils rattachés au robot. On cherche des batteries adaptées pour alimenter tout ça. C’est que ça pompe du courant ce ptit machin.

Il reste encore du boulot, le robot a la fâcheuse tendance à se mettre en mode autiste et à faire n’importe quoi. On a écarté un problème lié au wifi, donc ça doit venir du code qui marche paaaas bien Reste ensuite à faire marcher la pince, qui n’a pas encore été implémentée dans le code. Ensuite on pourra utiliser OpenCV pour faire un peu de traitement d’image et donner la possibilité au robot de repérer un certain nombre de choses.

Je suis en train de me préparer un blog perso exprès pour présenter l’avancement de mes projets de robotique, et de programmation en générale. Je posterai de temps en temps sur Coder-Studio mon avancement du projet et donnerai à l’occasion l’adresse pour compléter mes billets sur mes robots. Sinon, désolé pour la vidéo, elle est assez courte et on ne voit pas trop la manette de wii. En fait je n’avais plus de place sur ma carte mémoire…

Voilà donc c’est un premier aperçu très rapide du projet. Je ferai une vidéo plus complète au prochain épisode avec un billet contenant plus de détails sur le robot

Mon premier billet sur ce blog dresse une liste de quelques « trucs et astuces » utiles dans un environnement GNU/Linux. Cette liste sera progressivement complétée à l’avenir. On considère ici que le shell utilisé est bash. Les astuces sont facilement transposables à d’autres shells.

Sommaire :

1. Backspace sous Firefox
2. Suppression de fichiers
3. Recherche de texte dans les pages de manuel
4. Coloration syntaxique sous nano
5. Manpages en couleur
6. Coloration syntaxique avec enscript
7. Renommage de fichiers massif
8. Couleurs sous grep
9. Terminal & répertoire de travail
10. Tuer un processus par son nom
11. Détacher une commande d’un terminal
12. Backup des paquets sous Debian / Ubuntu
13. Expansion d’accolades
14. Recherche de fichiers
15. Remplacement de chaînes dans des fichiers
16. Création de répertoires
17. Récupération de codes de retour
18. Raccourcis clavier sous bash
19. Génération de chaîne aléatoire
20. Réutilisation de commandes et d’arguments
21. Recherche rapide dans un fichier
22. Décompression d’archives
23. Comparaison de fichiers
24. Comparaison de fichiers via ssh

1 – Backspace sous Firefox

Cette première astuce permet d’activer la touche backspace pour revenir aux pages précédentes sous Firefox. Voici la démarche à suivre :

1. Démarrer Firefox.
2. Taper about:config dans la barre d’adresse.
3. Taper backspace dans le champ filtre de la page pour voir apparaître la clé browser.backspace_action.
4. Remplacer la valeur de la clé par 0.

2 – Suppression de fichiers

La plupart des adeptes de la console sous GNU/Linux savent que la suppression des fichiers / répertoires est définitive. Même avec la meilleure des attentions, il reste possible de supprimer un fichier / répertoire par erreur. Pour pallier ce problème, une solution simple est de dériver le comportement initial de la commande rm. Le code qui suit se place dans le fichier ~/.bashrc :

function Delete()
{
	mv $@ $HOME/.local/share/Trash/files/
}
 
function Purge()
{
	\rm -rf $HOME/.local/share/Trash/files/*
	\rm -rf $HOME/.local/share/Trash/info/*
}
 
alias rm='Delete'
alias purge='Purge'

La première fonction sert à supprimer déplacer les fichiers dans la corbeille tandis que la seconde vide son contenu.
Note: sur les anciennes version d’Ubuntu par exemple, la corbeille pointait sur ~/.Trash.

3 – Recherche de texte dans les pages de manuel

Les pages de manuel sont un outil essentiel pour tout programmeur sous GNU/Linux. Seulement parfois, certaines pages sont très longues (ex: gcc) et on préfèrerait effectuer une recherche ciblée avec des mots-clés. Mais comment faire ? Admettons que nous souhaitions rechercher le mot-clé color dans la page de manuel de ls. Pour lancer une recherche, il suffit de taper /color. On accède ensuite aux occurences suivantes (respectivement précédentes) via la touche n (respectivement N).

4 – Coloration syntaxique sous nano

Beaucoup d’entres vous ont sans doute remarqué que la coloration syntaxique est absente par défaut sous l’éditeur nano. Nous allons donc voir comment l’activer simplement. Commencez par créer un fichier de configuration .nanorc à la racine de votre compte avec le contenu suivant puis sauvegardez :

## Fichier nanorc
include "/usr/share/nano/nanorc.nanorc"
 
## C/C++
include "/usr/share/nano/c.nanorc"
 
## HTML
include "/usr/share/nano/html.nanorc"
 
## TeX
include "/usr/share/nano/tex.nanorc"
 
## Emails
include "/usr/share/nano/mutt.nanorc"
 
## Fichiers patch
include "/usr/share/nano/patch.nanorc"
 
 
## Pages de manuel
include "/usr/share/nano/man.nanorc"
 
## Groff
include "/usr/share/nano/groff.nanorc"
 
## Perl
include "/usr/share/nano/perl.nanorc"
 
## Python
include "/usr/share/nano/python.nanorc"
 
## Ruby
include "/usr/share/nano/ruby.nanorc"
 
## Java
include "/usr/share/nano/java.nanorc"
 
## Assembleur
include "/usr/share/nano/asm.nanorc"
 
## Scripts bash
include "/usr/share/nano/sh.nanorc"
 
## POV-Ray
include "/usr/share/nano/pov.nanorc"

Chaque instruction correspond à l’inclusion d’un fichier à l’extension .nanorc. Ces fichiers contiennent en fait des paramètres de coloration syntaxique pour divers langages (ex: java pour le fichier java.nanorc). Vous pouvez dores et déjà admirer le résultat en éditant un fichier C/C++.

Néanmoins, on peut noter que la coloration de certains types de fichiers (.ini, .sourcelist, .conf, .php, .css et .xml) est absente. Manuel Dorne (alias Korben) met à disposition sur son blog une archive contenant les fichiers de coloration correspondant. Il suffit ensuite de rajouter les lignes suivantes à votre fichier de configuration ~/.nanorc :

## Sources.list
include "/usr/share/nano/sourceslist.nanorc"
 
## Fichiers de config. (.ini)
include "/usr/share/nano/ini.nanorc"
 
## Xorg.conf
include "/usr/share/nano/xorg.nanorc"
 
## CSS
include "/usr/share/nano/css.nanorc"
 
## XML
include "/usr/share/nano/xml.nanorc"
 
## Generic .conf
include "/usr/share/nano/conf.nanorc"
 
## PHP
include "/usr/share/nano/php.nanorc"

5 – Manpages en couleur

Qui n’a jamais rêvé d’avoir ses pages de manuel en couleur ? Ajoutez simplement les lignes suivantes à votre fichier de configuration ~/.bashrc :

export LESS_TERMCAP_mb=$'\E[01;31m'       # begin blinking
export LESS_TERMCAP_md=$'\E[01;38;5;74m'  # begin bold
export LESS_TERMCAP_me=$'\E[0m'           # end mode
export LESS_TERMCAP_se=$'\E[0m'           # end standout-mode
export LESS_TERMCAP_so=$'\E[38;5;246m'    # begin standout-mode - info box
export LESS_TERMCAP_ue=$'\E[0m'           # end underline
export LESS_TERMCAP_us=$'\E[04;38;5;146m' # begin underline

Cette page indique comment utiliser d’autres codes couleurs.

6 – Coloration syntaxique avec enscript

La commande enscript transforme un fichier texte au format ASCII en PostScript/HTML et permet accessoirement de faire de la coloration syntaxique. Commencez d’abord par installer le paquet correspondant (paquet enscript sous Debian/Ubuntu). Ensuite, il suffit de convertir le fichier désiré à l’aide de la commande. Voici un exemple de transformation d’un fichier assembleur en fichier HTML avec coloration :

enscript -Easm --color -whtml -poutput.html main.asm

La liste des langages disponibles est accessible via la commande suivante :

enscript --help-highlight | awk '$0 ~/Name:/ {FS=" "; print $2;}'

7 – Renommage de fichiers massif

Si vous en avez marre de renommer à la main tous les fichiers musicaux de votre audiothèque alors cette astuce est faite pour vous.

• rename
  Pour renommer massivement des fichiers, le moyen le plus simple est d’utiliser la commande rename dont les expressions régulières sont similaires à celles de la commande sed.Supposons que nous ayions une liste de chansons nommées ainsi :
  ^?View Code SHELL

  01-Les Histoires de Martin-Martin et les abeilles.ogg 02-Les Histoires de Martin-Martin chez les scouts.ogg 03-Les Histoires de Martin-Martin aime Martine.ogg

  On souhaite supprimer les numéros des chansons. Il suffit de lancer la commande suivante :

  ^?View Code SHELL

  rename 's/(.*)-(.*)-(.*).ogg/$1-$3.ogg/' *.ogg

  où $k correspond au k-ième match indiqué entre parenthèses par (.*).

  On obtient alors :

  ^?View Code SHELL

  01-Martin et les abeilles.ogg 02-Martin chez les scouts.ogg 03-Martin aime Martine.ogg

  Pour mettre en majuscule le noms des fichiers, il faut utiliser l’option y :

  ^?View Code SHELL

  rename 's/(.*)-(.*)-(.*).ogg/$1-$3.ogg/;y/[a-z]/[A-Z]/' *.ogg

  Note: le flag -n permet de pré-visualiser le renommage (pratique pour éviter les éventuelles bourdes).

• Mmv
  Alternativement à rename, le renommage massif peut aussi être effectué via Mmv (paquet mmv sous Debian/Ubuntu), bien plus puissant. Mmv est composé d’un ensemble de commandes capables de déplacer (mmv), copier (mcp) et créer des liens symboliques (mln) sur des fichiers. Supposons que nous ayions une liste de recettes de cuisine avec le nom de l’auteur :
  ^?View Code SHELL

  26-11-1988_Martin_Gâteau au chocolat.texte 19-04-1972_Elsa_Babas au rhum.texte 03-12-1995_John_Cookies américains.texte

  On souhaite maintenant renommer ces fichiers en excluant la date et en modifiant l’extension en .txt. On exécute alors la commande qui suit :

  ^?View Code SHELL

  mmv -n "*_*_*.texte" "#3 - #2.txt"

  où #k correspond au k-ième match indiqué par un joker (? ou *).

  On obtient alors :

  ^?View Code SHELL

  Gâteau au chocolat - Martin.txt Babas au rhum - Elsa.txt Cookies américains - John.txt

  Pour mettre en majuscule (respectivement minuscule) tous les fichiers, il faut indiquer u dans l’expression #k (respectivement l) :

  ^?View Code SHELL

  mmv -n "*.texte" "#u1.txt"

  L’option -r permet d’inclure les répertoire à renommer.

  On peut aussi ajouter les recettes les unes à la suite des autres via l’option -a :

  ^?View Code SHELL

  mmv -a "*.texte "recettes.texte"

  Note: là encore, le flag -n permet de pré-visualiser le renommage.

  Pour les adeptes de la souris, il existe d’autres outils de renommage comme Métamorphose, dotés d’une interface plus user-friendly. Plus d’infos sur ce site : http://file-folder-ren.sourceforge.net.

8 – Couleurs sous grep

La commande grep s’avère souvent utile pour rechercher facilement un motif dans un flux de données (stdin ou fichier). Néanmoins, il devient difficile de reconnaître le motif lorsque les lignes matchées sont de grande taille. Un moyen simple est d’activer la coloration en plaçant l’alias suivant dans votre fichier ~/.bashrc :

alias grep="grep --color=auto"

La coloration peut-être paramétrée en modifiant la variable GREP_COLORS. Plus d’infos sur la manpage de grep. Une liste détaillée des couleurs est accessible sur ce site : site.

9 – Terminal & répertoire de travail

Beaucoup d’entre vous auront sans doute remarqué que le chemin et l’historique des commandes n’est pas sauvegardé lors du lancement d’un nouveau terminal. Pour pallier ce problème, il suffit de modifier la variable PROMPT_COMMAND du fichier ~/.bashrc. Supposons que cette variable ait le contenu suivant (par défaut sous Debian/Ubuntu) :

PROMPT_COMMAND='echo -ne "\033]0;${USER}@${HOSTNAME}: ${PWD/$HOME/~}\007"'

On la modifie alors comme suit :

PROMPT_COMMAND='echo `pwd` > ~/.oldpwd; history -a; echo -ne "\033]0;${USER}@${HOSTNAME}: ${PWD/$HOME/~}\007"'

La première commande permet de sauvegarder le chemin courant dans le fichier .oldpwd tandis que la seconde sauvegarde l’historique.

Puis, à la fin du fichier, rajoutez cette ligne :

cd "`cat ~/.oldpwd`"

Du coup, à l’ouverture d’un nouveau terminal (xterm, kconsole, etc.), le chemin et l’historique des commandes sera conservé. Pratique non ?

10 – Tuer un processus par son nom

Pour tuer un processus qui semble ne plus répondre, on procède généralement de la manière suivante :

• On récupère le numéro du processus via :
  ^?View Code SHELL

  pid=$(ps -ef | grep nom_processus)

• Puis, on tue le processus en lui envoyant un signal SIGKILL via :
  ^?View Code SHELL

  kill -9 ${pid}

Une méthode alternative, plus courte, consiste à appeler la commande killall en lui passant directement le nom du processus :

  killall nom_processus

11 – Détacher une commande d’un terminal

Un utilisateur est souvent amené à lancer des applications à partir d’un terminal (browser, lecteur audio, etc.). Parfois, il arrive aussi que l’on ferme un terminal par erreur. Cela a pour effet d’arrêter toutes les applications lancées à partir de ce terminal. Pour pallier ce problème, il suffit de détacher l’application du terminal via :

nohup application &

Par défaut, la commande nohup crée un fichier de sortie nohup.out contenant la sortie standard de la commande passée en paramètre. On peut supprimer ce comportement en redirigeant tous les flux vers /dev/null :

nohup application &>/dev/null &

Libre à vous ensuite d’ajouter un alias dans votre .bashrc

12 – Backup des paquets sous Debian / Ubuntu

Lorsqu’on fait une réinstallation complète, on oublie parfois de sauvegarder la liste des paquets installés. Du coup, on ne réinstalle uniquement qu’une petite partie des paquets dont on a besoin. Voici comment procéder pour faire une backup de la liste des paquets installés.

Récupérez la liste des paquets installés sur le système dans un fichier appelé packages.txt :

sudo dpkg --get-selections > packages.txt

Sauvegardez ce fichier sur CD, disquette ou clé USB. Ensuite, lors de la réinstallation, copiez ce fichier sur le disque dur et exécutez les trois commandes suivantes pour récupérer et installer vos paquets :

sudo dpkg --set-selections < packages.txt
sudo apt-get update
sudo apt-get dselect-upgrade

Pour éviter de télécharger à nouveau vos paquets, vous pouvez encore gagner du temps en les gravant directement sur CD. Ce lien explique la marche à suivre.

13 – Expansion d’accolades

Sous bash, l’expansion d’accolades (braces expansion) est un mécanisme souvent méconnu mais extrêmement puissant qui permet de générer des chaînes de caractères arbitraires. Ce mécanisme est similaire à l’expansion de noms de fichiers hormis le fait qu’ils n’ont pas besoin d’exister. Les chaînes de caractères à générer sont décrites par des patterns. Ces patterns sont entourés d’accolades et séparés par des virgules. Chaque pattern peut lui-même être décrit par une liste de patterns. L’expansion s’effectue toujours de gauche à droite.

L’exemple qui suit permet de générer les chaînes ade, ace et abe.

echo a{d,c,b}e
ade ace abe

Les patterns peuvent aussi contenir des nombres contenus dans un intervalle donné (un argument d’incrément est disponible uniquement à partir de bash 4). Par exemple, on peut vouloir générer les chaînes A0 à A9 pour chacune des lettres de l’alphabet :

echo {A..Z}{0..9}
A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 G0 G1 G2 G3 G4 G5 G6 G7 G8 G9 H0 H1 H2 H3 H4 H5 H6 H7 H8 H9 I0 I1 I2 I3 I4 I5 I6 I7 I8 I9 J0 J1 J2 J3 J4 J5 J6 J7 J8 J9 K0 K1 K2 K3 K4 K5 K6 K7 K8 K9 L0 L1 L2 L3 L4 L5 L6 L7 L8 L9 M0 M1 M2 M3 M4 M5 M6 M7 M8 M9 N0 N1 N2 N3 N4 N5 N6 N7 N8 N9 O0 O1 O2 O3 O4 O5 O6 O7 O8 O9 P0 P1 P2 P3 P4 P5 P6 P7 P8 P9 Q0 Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 S0 S1 S2 S3 S4 S5 S6 S7 S8 S9 T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 U0 U1 U2 U3 U4 U5 U6 U7 U8 U9 V0 V1 V2 V3 V4 V5 V6 V7 V8 V9 W0 W1 W2 W3 W4 W5 W6 W7 W8 W9 X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 Y0 Y1 Y2 Y3 Y4 Y5 Y6 Y7 Y8 Y9 Z0 Z1 Z2 Z3 Z4 Z5 Z6 Z7 Z8 Z9

En pratique, l’expansion d’accolades est un mécanisme très agréable. On peut notamment l’utiliser pour faire une copie d’un fichier en évitant de retaper son nom :

cp /home/rantanplan/medias/photos/mariage_de_loic/27/02/1998/originaux/photo1.jpg{,.bak}

Autre exemple concret : on souhaite récupérer plusieurs pages web qui ne diffèrent que par un numéro. Là encore, l’expansion d’accolades nous évite de recopier n fois le nom du fichier sur la ligne de commande ou bien d’utiliser explicitement une boucle :

wget http://docs.example.com/documentation/slides_part{1..6}.html

14 – Recherche de fichiers

Parfois, il arrive que l’on souhaite effectuer une recherche d’un motif particulier à l’intérieur de fichiers situés dans plusieurs répertoires. Seulement, on aimerait limiter la recherche à quelques types de fichiers précis.

Par exemple, supposons que l’on veuille rechercher le motif « volume3D » à l’intérieur de fichiers C/C++. Cela est facilement réalisable en utilisant l’expansion d’accolades (cf. section 13) sur le paramètre –include de la commande grep :

grep -R . -e "volume3D" --include=*.{c*,h*}

15 – Remplacement de chaînes dans des fichiers

On veut parfois remplacer une chaîne de caractère dans plusieurs fichiers. Une manière simple de réaliser cela est d’utiliser l’interpréteur Perl. Supposons que l’on veuille remplacer la chaîne « tomate » par « salade » dans un ensemble de fichiers texte. Il suffit alors de taper la commande qui suit :

perl -pi -e "s/tomate/salade/g" *.txt

Cela permet un gain de temps considérable surtout lorsque le nombre de fichiers est élevé

16 – Création de répertoires

Lors de la création d’une nouvelle arborescence, beaucoup de gens ont l’habitude de créer un par un les répertoires via mkdir puis de les déplacer via mv. Un moyen plus simple est d’utiliser l’option -p de la commande mkdir qui crée automatiquement les répertoires parents. Supposons que l’on souhaite avoir une arborescence de photos de vacances classées par lieu puis par date :

photos_vacances/
|-- Antibes
|   |-- 2008
|   |   `-- 07
|   |       |-- 28
|   |       |-- 29
|   |       |-- 30
|   |       `-- 31
|   `-- 2009
|       `-- 07
|           |-- 12
|           |-- 13
|           |-- 14
|           |-- 15
|           |-- 16
|           |-- 17
|           |-- 18
|           |-- 19
|           `-- 20
`-- Lyon
    |-- 1999
    |   `-- 08
    |       |-- 01
    |       |-- 02
    |       |-- 03
    |       `-- 04
    `-- 2002
        |-- 07
        |   |-- 12
        |   |-- 13
        |   |-- 14
        |   |-- 15
        |   `-- 16
        `-- 12
            |-- 24
            |-- 25
            |-- 26
            |-- 27
            `-- 28

En combinant l’expansion d’accolades, on obtient alors les commandes suivantes :

mkdir -p photos_vacances/Antibes/2008/07/{28..31}
mkdir -p photos_vacances/Antibes/2009/07/{12..20}
mkdir -p photos_vacances/Lyon/1999/08/0{1..4}
mkdir -p photos_vacances/Lyon/2002/07/{12..16}
mkdir -p photos_vacances/Lyon/2002/12/{24..28}

17 – Récupération de codes de retour

Parfois, on aimerait pouvoir récupérer un code de retour précis sur une commande composée de plusieurs pipes. Par exemple, imaginons que nous souhaitions savoir si l’utilisateur « daniel » est connecté sur une machine. Une commande possible serait alors la suivante (la commande sort n’est présente que pour illustrer l’exemple) :

who | awk '{print $1}' | grep "daniel" | sort

Sous Bash, il est possible de récupérer les codes de retour de chacune des commandes dans un tableau appelé PIPESTATUS. Pour obtenir les codes de retour, il suffit alors de consulter ce tableau :

echo ${PIPESTATUS[*]}

Dans l’exemple, si l’utilisateur « daniel » n’est pas connecté, la commande précédente afficherait ceci :

0 0 1 0

18 – Raccourcis clavier sous bash

Voici une sélection des raccourcis clavier utiles sous bash :

• Ctrl+U : supprimer tout ce qui est présent à gauche
• Ctrl+W : supprimer uniquement le premier mot à gauche
• Ctrl+Y : coller le contenu du buffer
• Ctrl+A : se déplacer au début de la ligne
• Ctrl+E : se déplacer à la fin de la ligne

19 – Génération de chaîne aléatoire

Une méthode rapide et simple pour générer une chaîne aléatoire est de remplacer les symboles issus du fichier /dev/urandom par des caractères alphanumériques et de couper à la longueur désirée :

< /dev/urandom tr -dc A-Za-z0-9 | head -c8

20 – Réutilisation de commandes et d’arguments

Sur un terminal, on passe généralement beaucoup de temps à rappeler des commandes antérieures ou des commandes qui ne diffèrent seulement que par quelques arguments. Par exemple, supposons que nous ayons tapé la commande cd foo et qu’elle retourne un message d’erreur indiquant que le répertoire foo n’existe pas. Supposons maintenant que nous souhaitions créer ce répertoire. Cela implique donc de rappeler la commande précédente, de l’éditer et de la lancer. Dans bien des cas, ces étapes sont fastidieuses. Bash propose une liste d’alias, souvent méconnue, qui permet de gagner un temps précieux :

• !n : rappelle la commande numéro n
• !-n : rappelle la commande exécutée il y a n commandes
• !! : rappelle la dernière commande
• !chaine : rappelle la commande la plus récente commençant par « chaine »
• !?chaine : rappelle la commande la plus récente finissant par « chaine »
• !?chaine? : rappelle la commande la plus récente contenant par « chaine »
• ^chaine1^chaine2^ : répète la dernière commande en remplaçant « chaine1″ par « chaine2″
• !# : rappelle la plus ancienne commande
• commande !^ : exécute « commande » avec le premier argument de la commande précédente
• commande !:n : exécute « commande » avec l’argument numéro n de la commande précédente
• commande !:x-y : exécute « commande » avec les arguments numéro « x » à « y » de la commande précédente
• commande !$ : exécute « commande » avec le dernier argument de la commande précédente
• commande !-2$ : exécute « commande » avec le dernier argument de l’avant dernière commande

Un exemple d’utilisation est lorsque l’on oublie de préfixer une commande par « sudo ». Pour rappeler la commande précédente en rajoutant ce préfixe, il suffit alors de taper : sudo !!.

21 – Recherche rapide dans un fichier

Un moyen rapide et concis de rechercher un motif dans un fichier fichier.txt (sans passer par la commande cat) est le suivant :

< fichier.txt grep -n "motif"

La commande peut alors aisément être complétée pour compter par exemple le nombre de matchs :

< fichier.txt grep -n "motif" | wc -l

22 – Décompression d’archives

Marre de se rappeler les arguments à passer pour décompresser une archive tar.gz, .zip, .rar, etc. ? Voici une commande générique pour décompresser n’importe quelle type d’archive :

extract()
{
    if [ -f $1 ]; then
        case $1 in
         *.tar.bz2) tar xvjf $1;;
         *.tar.gz)  tar xvzf $1;;
         *.bz2)     bunzip2 $1;;
         *.rar)     unrar x $1;;
         *.gz)      gunzip $1;;
         *.tar)     tar xvf $1;;
         *.tbz2)    tar xvjf $1;;
         *.tgz)     tar xvzf $1;;
         *.zip)     unzip $1;;
         *.Z)       uncompress $1;;
         *.7z)      7z x $1;;
         *)         echo "'$1' cannot be extracted";;
        esac
    else
        echo "'$1' is not a valid file"
    fi
}

Une fois installé, on ne peut plus s’en passer

Source : shell-fu.org.

24 – Comparaison de fichiers

Un moyen simple de pouvoir comparer le contenu de deux répertoires est d’utiliser la commande diff comme suit :

diff -u (ls -c1 repertoire1) < (ls -c1 repertoire2)

Note : l’option c1 passée à ls liste les fichiers en une seule colonne.

24 – Comparaison de fichiers via ssh

La commande ci-dessous permet de comparer deux fichiers à travers ssh :

ssh login@hostname "cat /tmp/fichier_distant.txt" | diff - /tmp/fichier_local.txt

Carte Fox

J’ai été amené à travailler dans le cadre de mes études sur un petit projet de développement d’une Interface GSM sur un système Linux embarqué. Ayant découvert la puissance du système, j’ai pensé vous faire part de mes découvertes sur l’utilisation de cette carte.

Dans mon cas le principe était de créer un système autonome d’envoi de SMS aux étudiants de mon école. L’idée étant de pouvoir envoyer les résultats des examens directement par SMS aux étudiants, ce qui est ma foi fort sympatique

Le Matériel

Alors, tout d’abord : Carte FOX Késako !? Il s’agit d’un système embarqué à bas coût utilisant le système d’exploitation Linux. La carte est dotée d’un processeur AXIS à 100MHz et de 32 MB de RAM, de connectiques USB, Ethernet, d’un port série console ainsi que 40 pins pouvant être reliées à plusieurs BUS de données. Elle permet de développer en bon nombre de langages : C, C++, PHP, PYTHON, Shell, … et permet des connections HTTP, FTP, SSH et TELNET. De petite taille et faible consommation électrique (1 W) est idéale pour mettre en place rapidement des projets de type embarqué.

Modem GSM

Le modem GSM utilisé ici est un modem de la marque Telit. Il est relié à la carte FOX par l’intermédiaire d’une carte d’extension. La carte FOX peut communiquer avec le modem par l’intermédiaire du port série /dev/ttyS2. Une simple utilisation de carte SIM classique permet de se connecter au réseau GSM. Il est possible de trouver cette carte seule sur le site d’ACME SYSTEMS à 176 € frais de port tout compris. Si l’on ajoute le kit GPRS cela monte jusqu’à 626 €, ce qui commence déjà à faire beaucoup. Je pense qu’une solution plus abordable serait de relier la carte basique à un téléphone portable pour communiquer en série étant donné que dans notre cas nous n’avons pas besoin de tous les éléments de la carte d’extension.

Les modems GSM utilisent un protocole de commandes appelées « commandes AT ». Chaque constructeur fait un peu ce qu’il veut avec ses normes, ce qui fait que chaque modem est plus ou moins différent et qu’il faut se référer à la doc du constructeur. Ces commandes AT sont donc envoyées via le port série pour soumettre différentes commandes au modem. On peut notamment dans notre cas manipuler et envoyer des SMS par l’intermédiaire de celles-ci.

Environnement de développement

La compilation d’un programme en C sur la carte fox nécessite un compilateur croisé permettant de compiler le code C pour les processeurs AXIS. La compilation directe sur la carte n’étant pas possible, il faut par conséquent utiliser un SDK pour compiler le programme. J’ai travaillé avec le SDK Axis fourni pour la carte fox.

Avant toute chose il faut se rendre dans le dossier du SDK (~/devboard-R2_01 pour ma part) et y taper la commande suivante afin d’initialiser l’environnement de développement.

. init_env

Ensuite, il faut choisir le compilateur AXIS

make cris-axis-linux-gnu

On doit alors créer un Makefile pour notre programme. Voici celui que j’ai créé :

AXIS_USABLE_LIBS=UCLIBC GLIBC
include $(AXIS_TOP_DIR)/tools/build/Rules.axis
PROGS = sms
INSTDIR= $(prefix)/mnt/flash
INSTMODE= 0755
INSTOWNER= root
INSTGROUP= root
OBJS = main.o atcommand.o modem.o
all: $(PROGS)
$(PROGS): $(OBJS)
$(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@
scp sms root@fox01:/mnt/flash/tx
clean:
rm -f *.o
rm -f sms

Il n’y a alors plus qu’à faire un make pour compiler le programme et à l’envoyer sur la carte en FTP ou SCP. Ayant dû compiler à de très nombreuses reprises mon programme, j’ai rajouté l’envoi du fichier dans le makefile via la commande scp. Les fichiers utilisateurs sont déposés sur la carte Flash dans le répertoire /mnt/flash. Attention toutefois, car la mémoire flash EPROM est limitée en nombre d’écritures. Il vaut mieux tant que possible éviter d’écrire dans cette mémoire régulièrement. Privilégier la RAM (dossier /var par exemple) plutôt que sur la carte flash. Seul soucis, la carte se réinitialise à chaque redémarrage, par conséquent les tests peuvent être faits en RAM et une fois que l’application compilée est stable il est préférable de la déposer sur la carte flash afin de ne pas perdre le programme à chaque reboot.

La connexion à la carte fox se fait en telnet (ou ssh) simplement à l’aide de la commande suivante grâce à un simple telnet

telnet adresse_ip_de_la_fox

Développement du programme

Utilisation des commandes AT

Le modem se commande directement grâce aux commandes AT.  Ces commandes AT suivent une certaine syntaxe et nécessitent une mise en forme particulière pour leur envoi sur le modem. Ce dernier reconnaît plusieurs caractères de contrôle :

<CR> : Caractère de retour chariot : Sa valeur ASCII en décimal est fixée à 13 par défaut. (et peut être changée grâce au paramètre AT S3) Sa valeur hexadécimale quant à elle est 0×0D.

<LF> : Caractère d’interligne : Sa valeur ASCII en décimal est fixée à 10 par défaut

<CTRL+Z> : Combinaison des touches CTRL et Z. Sa valeur hexa est 0×1A

Ces caractères sont demandés et utilisés par le modem pour identifier les commandes AT. Chacune d’entre-elles utilise ces caractères de contrôle plus ou moins différemment. Voici un aperçu des différentes commandes que j’ai utilisées avec leurs caractères de contrôle.

ATE0<CR>
Cette commande permet de désactiver la commande écho (ATE1 la réactive). Cela demande donc au modem de ne pas répéter systématiquement les commandes qui lui sont envoyées.

AT+CMGF=1<CR>

Cette commande permet de régler le format de message pour l’envoi de SMS. Par défaut, le modem est en mode PDU (AT+CMGF=0). C’est-à-dire que l’envoi de message se fait en hexadécimal. AT+CMGF=1 permet de passer en mode texte, ce qui simplifie les manipulations de SMS.

AT+CMGS= »06XXXXXXXX »<CR>

Cette commande permet de commencer la rédaction d’un SMS. On précise en argument le numéro de téléphone choisi. En retour on obtient le caractère d’invite de commande « > » qui nous invite à rentrer le texte du SMS.

Texte du SMS<CTRL+Z><CR>
Cette fin de commande permet alors de préciser le texte et de valider l’envoi du SMS par un CTRL+Z et un retour chariot.

Il est important de noter que l’envoi de la commande AT d’envoi de SMS se fait en 2 parties et pas en un coup. (j’ai testé pendant plusieurs semaines… ça ne marche pas ^^)

Le modem répond à ces commandes par des messages de retour. Ces derniers indiquent si celles-ci ont été exécutées avec succès ou non. La plupart de ces réponses sont entourées des caractères <CR><LF> Il y a toutefois des exceptions, notamment pour AT+CMGS qui renvoie +CMGS: <mr> ou +CMS ERROR: <err> Mais dans la plupart des cas les retours sont rapportés de la manière suivante :
<CR><LF>OK<CR><LF>
<CR><LF>ERROR<CR><LF>
<CR><LF>…<CR><LF>

Ces commandes AT doivent être transmises au modem par le port série /dev/ttyS2. Il existe plusieurs façons de communiquer sur le port série :

Termnetd (http://foxlx.acmesystems.it/?id=69)

Il s’agit d’un processus permettant de relier un port TCP/IP à un port série de manière transparente. Une fois que le deamon est lancé sur la carte fox, il est possible de se connecter depuis l’extérieur grâce à la commande telnet adress_ip_fox 7000. Le port 7000 (choisi dans la config de termnetd) redirige directement sur le port série et il est alors possible de rentrer manuellement des commandes AT et de voir leur comportement direct sur le modem. Ce programme est utile pour comprendre le fonctionnement des commandes AT.

Script Chat (http://linux.about.com/od/commands/l/blcmdl8_chat.htm)
Il est possible d’utiliser la commande UNIX chat permettant de dialoguer de manière automatisée avec le modem.

/usr/sbin/chat -V -s -f <fichier_script> > /dev/ttyS2 < /dev/ttyS2 2><fichier_resultat>

La réponse du modem est alors enregistrée dans le fichier de résultat choisi.

Programme en C
Il est également possible de dialoguer avec le modem via un programme C. Le dialogue se fait alors en écrivant et en lisant sur /dev/ttyS2. La prise en main est beaucoup plus complexe que les 2 précédentes méthodes, mais permet une totale maitrise du modem.

Développement en C

Le code pour envoyer un SMS n’est pas bien compliqué, mon but n’est pas là de copier/coller intégralement mon code, mais plutôt d’expliquer les grandes lignes son fonctionnement et de vous donner envie de bidouiller une carte fox ^^

L’idée est donc d’initialiser tout d’abord la connexion série à l’aide de Termios. La documentation sur le site du constructeur regorge d’informations et propose du code tout fait pour gérer la connexion série. Une fois la configuration réalisée (c’est très rapide à réaliser), il n’y a plus qu’à faire un write sur /dev/ttyS2

char command1[50];
char command2[50];
sprintf(command1, "AT+CMGS="%s"x0D", number);
sprintf(command2, "%sx1Ax0D", text);
write (tty_fd, command1, strlen(command1));
sleep(1); // attend la réponse du modem afin d'envoyer la seconde partie
write(tty_fd,command2,strlen(command2));

Et le SMS est envoyé ! Après libre à vous de rajouter à la suite une lecture de la réponse du modem (gentil petit read). Dès lors il est possible de se faire une petite fonction d’envoi de SMS à partir d’arguments tels que le numéro de téléphone et le texte du message. J’en ai profité pour me rajouter un système de logs et de manipulation du modem (redémarrage, arrêt). Je me suis créé une interface web en bash (scripts cgi) et par simples appels de notre programme C il est alors possible de se construire une application métier complexe. On a plus qu’à brancher notre carte fox sur le réseau et celle-ci peut envoyer des SMS à distance de manière assistée grâce à des formulaires web !

Préparation de la carte FOX

Dernier point de précision: au démarrage, le modem n’est pas allumé ni configuré. Il faut par conséquent créer un script de démarrage à déposer dans /etc/init.d/boottime . Voici le script que j’ai utilisé:

#!/bin/sh
# démarrage du modem
setbits -p b -b 7 -s 1
# Lancement de termnetd (pour les tests)
/mnt/flash/termnetd
# Initialisation série du modem (mon petit programme d’initialisation de la connexion série)
/mnt/flash/tx/sms -init
sleep 20
# Initialisation AT du modem
/usr/sbin/chat -V -s -f /mnt/flash/tx/scripts/scriptAT.chat >
/dev/ttyS2 < /dev/ttyS2 2> /mnt/flash/tx/scripts/scriptAT_result.txt
# Ecriture des logs (pour le fun ^^)
echo “`date` : MODEM start” >> /mnt/flash/tx/log/fox.log

On commence par allumer le modem, on initialise la connexion série avec le programme en C puis attend 20 secondes que le modem soit identifié sur le réseau. Le temps choisi est totalement arbitraire. Cela semble fonctionner correctement avec cette période, mais idéalement il serait intéressant d’interroger le modem pour déterminer s’il est bien connecté au réseau. Ensuite on exécute un script chat que voici :

ABORT BUSY
ABORT 'NO CARRIER'
ABORT ERROR
'' AT
OK ATZ
OK 'ATE0'
OK 'AT+CMGF=1'
OK ''

Ce dernier permet de désactiver l’écho afin de ne pas recevoir mes commandes en double, et permet d’activer le mode texte pour l’envoi de SMS. Par défaut l’envoi de SMS se fait en mode PDU (sous forme hexadécimale), ce qui est bien plus compliqué à utiliser. Une fois ce script exécuté, le modem est prêt à être utilisé. On peut rajouter un log à la fin pour identifier le démarrage du modem.

La carte fox est une carte embarqué assez simple à prendre en main, les utilisations sont assez illimités. Le rêve de tout bidouilleur !
Je songe à m’en commander une très bientôt, je ne peux pas résister à tant de potentiel de bidouille.

A suivre : Comment connecter la carte fox au réseau GPRS pour pouvoir aller sur le net et envoyer des mail