[How-To] Use Gmail to Remote Control your PC

lien : http://technofriends.in/2008/04/28/how-to-use-gmail-to-remote-control-your-pc/

Its a known fact that Gmail is the most popular email service available today. Though, utilities for using Gmail as a disk space were out pretty long back; there is another interesting utility called GCALDaemon which can be used to remote control your PC using Gmail.

GCALDaemon is an OS-independent Java program that offers two-way synchronization between Google Calendar and various iCalendar compatible calendar applications. GCALDaemon was primarily designed as a calendar synchronizer but it can also be used as a Gmail notifier, Address Book importer, Gmail terminal and RSS feed converter. GCALDaemon uses very less memory ( ~ 10-20 MB) and runs in service mode on Windows NT/2000/XP.

GCALDaemon, when initially installed, is not configured to do anything. Based on the services you wish to use, it should be configured. In this post, we shall be using GCALDaemon to remote control our PC. As a practical implementation, this scenario can be useful to users who have a very protected network but still wish to do certain tasks with it. It assumes that port 80 of your computer is open.

GCALDaemon’s ‘mailterm’ service enables Gmail users to remotely control their PC by sending an email to their Gmail account. This management service keeps checking a Gmail inbox regularly, if it finds an email from a trusted sender and with a secret subject, it reads and executes a specified script file. Then GCALDaemon sends back a response, which contains the script’s output. Most mobile carriers and recent phones have built-in support for sending email through SMS gateways, therefore a simple cellural phone should be enough to manage a computer.

In order to configure ‘mailterm‘ service follow the steps mentioned below

1.) Install GCALDaemon. You can download GCALDaemon from here

2.) Enable IMAP on your Gmail. Check my previous postGmail gets IMAP Support for further information on this.

3.) You will need to encode your Password by starting out the Password Encoder application. This application takes in your Gmail Password and encodes it. Copy the encoded password.

4.) Open ‘gcal-daemon.cfg’ and edit the same with your favorite text editor. On Windows, this file is located in C:\Program Files\GCalDaemon\conf\gcal-daemon.cfg as part of the default installation. In case, if you have chosen to change the installation path, please look for the file in the respective location.

A) Set the ‘mailterm.enabled’ property to ‘true’
B) Set the ‘mailterm.google.username’ property to your Gmail address
C) Set the ‘mailterm.google.password’ property to your encoded password

5.) At the time of setup, you may choose your own unique email subject for mailterm. This subject must be at least 6-8 characters long and contain a combination of letters and numbers. Basically, you do not want any word or number which can be associated with you, or typical in ordinary messages. The subject is case sensitive. Start the password encoder again, input your mailterm subject and press ENTER. Copy the encoded subject.

6.) 6) Edit the ‘gcal-daemon.cfg’ with text editor.

A) Put the encoded subject for the variable ‘mailterm.mail.subject’.
B) Put the list of the trusted e-mail senders for the variable ‘mailterm.allowed.addresses’.

7.) Create a new script file (BAT or SH) and save this file into the mailterm’s scipt folder (e.g. ‘/scripts/ls.bat‘). The folder’s location is determined by the ‘mailterm.dir.path’ property in the gcal-daemon.cfg file.

Setup finished – launch GCALDaemon.

9) Create a new mail message, put your mailterm subject for the mail’s title, and enter you mailterm command in script name [optional parameters] format. You can use either a single quotation mark (’) or quotation marks (”) to enclose script parameters.

10) Click on ‘Send’ button. You will receive the script’s output within 10 minutes after submitting your mail.

You can further do some fine adjustments to this installation. Please visit the official page of GCALDaemon for further details.

Also read: Interesting Gmail Hacks

How-to Exclude Chat from Gmail Search Results

How-to show unread mails at the top in your inbox in Gmail.

[How-to]: GUI en Matlab avec circuit RLC série

Ce tutoriel est créé par mon collègue Ali Diouri, responsable des calculs mathématiques dans mon équipe. Je vous fournit les documents en .pdf : tutorial_rlc_serie

Le paquet complet : http://www.megaupload.com/?d=39T6VGCW (je n’ai pas trouvé de hôtes)

Quelques mots : En commençant le GUI en Matlab, je n’ai pas trouvé beaucoup d’aide en graphique en ligne. C’est pourquoi on a décidé de faire un petit tutorial pour ceux qui commencent le GUI en Matlab.

On a décidé de prendre le circuit RLC en série pour développer cet outils. Cette exemple permet aussi à ceux qui voulaient comprendre circuit RLC en série.

Réalisation: HUB USB

Lien : http://www.lpmi.uhp-nancy.fr/realisation/USB/usbhub.html

Réalisez un Hub USB schéma complet avec le circuit imprimé. Hub 4 ports alimentation par le bus.

Réalisation Pautex JF ( LPMI 1999 )

Première sur le Net le schéma d’un Hub USB pour votre ordinateur, ce montage est en cours de test cette page sera mise à jour lors des tests complet et de l’assurance de fonctionnement de ce Hub. Le cout est très faible puisque vous devez vous procurer seulement les connecteurs USB et le quartz 6 MHz (RadioSpares) par exemple. Voir le site Texas pour la disponibilité des autres composants.

Keywords : USB, Hub USB

Schéma du montage :

Description :

La réalisation de ce Hub nécessite l’obtention de quelques CI que vous trouverez sur le Net.

Liste des composants de ce montage HUB :

SN75240P TPS2041D TPS76433DBVR TUSB2046VF MAX821 Quartz 6 MHz Connecteur A Connecteur B

3 1 1 1 1 1 2 1

Protection de bus (Texas ) Commutateur d’alimentation ( Texas ) Alimentation régulé 3,3 V ( Texas ) controleur USB ( Texas Instrument ) Power on reset ( MAXIM ) Quartz USB type A double USB type B simple

Ces composants sont tous disponibles sur les sites Internet des constructeurs en échantllons gratuits.

Circuit Photo du montage :

Fichiers au format pdf du circuit imprimé de ce montage

• Face soudure
• face composant

Réalisez l’impression de ces fichier sur transparents ou calque à l’aide d’une imprimante laser le circuit imprimé deux faces ne présente pas de difficultées particulière, la soudure du composant TSU2046 est délicate, un petit fer à souder convient parfaitement. On trouvera la disposition des élément sur le schéma ci-dessous.

Disposition des éléments de ce montage :

Introduction aux scripts shell

Lien : http://doc.ubuntu-fr.org/tutoriel/script_shell

Présentation

Un script shell permet d’automatiser une série d’opérations. Il se présente sous la forme d’un fichier contenant une ou plusieurs commandes qui seront exécutées de manière séquentielle.

Règles de base lors de l’écriture d’un script

• Des vérifications approfondies doivent être effectuées sur TOUTES les commandes utilisées.
• Des commentaires détaillés doivent apparaître lors de chaque étape. De même, chaque étape doit être suivie d’un « echo <voici ce que je fais> » (particulièrement utile notamment lors du débuggage).
• Lors d’une mise à jour, un fil de discussion doit être précisé pour tracer les bugs éventuels.
• Avertir les utilisateurs des dégâts que peuvent causer les commandes utilisées. (Ces deux dernières remarques ne concernent bien sûr que les scripts que l’on souhaite diffuser.)

Évidemment ces conseils sont utiles au débutant…

Astuce: Le plus important dans tout programme est l’algorithme utilisé

Exemple: Supposons que vous avez une base de données, avec 3 catégories d’enregistrements possibles: éléphant bleu, éléphant blanc, éléphant rose ayant chacun 30 individus. Votre script doit compter le nombre d’éléphants bleus et blancs. Deux possibilités s’offrent à vous:

1. calculer le nombre d’éléphants bleus + éléphants blancs

ou

1. calculer le nombre total d’éléphants – nombre d’éléphants roses

Quel algorithme choisissez-vous? Résultat: Le premier car dans le deuxième il faut d’abord calculer le nombre total d’éléphants, donc un calcul en plus.

Vous comprenez ?

OUUUUUUIIIIIIIIIIIIIIIIIIIIIII !

Ecrire un script

Si vous voulez écrire un programme sh, vous avez deux possibilités :

• soit vous tapez dans un shell toutes les commandes
• ou alors vous rassemblez toutes les instructions copiées par ci par là dans un fichier sh.

A titre d’exemple, saisissez ces quelques lignes dans votre éditeur préféré :

#!/bin/bash
# indique au système que l'argument qui suit est le programme utilisé pour exécuter ce fichier.
# En cas général les "#" servent à faire des commentaires comme ici
echo Mon premier script
echo Liste des fichiers :
ls -la

exit 0

Le résultat de ce script est d’écrire à l’écran « Mon premier script », puis en dessous « Liste des fichiers : », et enfin la liste des fichiers avec la commande `ls -la`.

Comme vous l’avez compris, la commande `echo` sert à écrire quelque chose à l’écran.

Cependant il vous faudra extrêmement bien faire attention a tous ces morceaux de code. Leur utilisation sans connaissance de votre part pourrait vous faire perdre de précieuses données.

Exécuter un script

D’ici, j’entends déjà les débutants dire :

Mais comment on exécute ce script ?

Et bien il suffit de se placer dans le dossier où est le script, et de lancer

bash nom_du_script

Si vous voulez l’exécuter avec « . », il faut le rendre exécutable avec `chmod`. Pour ceci tapez dans le shell la commande qui suit :

chmod +x nom_du_script

Puis vous pouvez exécuter le script en faisant :

./nom_du_script

Les différents types de shells

Comme vous avez surement dû l’entendre, il existe différents types de shells, dont le plus connu est, comme vous l’aurez deviné, ‘shell,’ qui signifie coquille. Il existe aussi:

• bash (Bourne Again SHell) : conçu par le projet GNU, shell linux ;
• rbash : un shell restreint basé sur bash. Il existe de nombreuses variantes de bash ;
• csh, tcsh : shells C, créés par Bill Joy de Berkeley ;
• zsh, shell C écrit par Paul Falstad ;
• ksh,pdksh : shells korn, écrits par David Korn ;
• rc : shell C, lui aussi conçu par le projet GNU ;
• tclsh : shell utilisant Tcl ;
• wish : shell utilisant Tk ;

Il existe bien entendu beaucoup d’autres types de shells.

Shell (sh) est en fait un lien vers /bin/bash, tout comme rbash.

Les structures de contrôle

Les tests : `if`

Avant de commencer à faire des scripts de 1000 lignes, il serait intéressant de voir comment se servir des variables, et des instructions if, then, elif, else, fi. Cela permet par exemple de faire réagir le script de manière différente, selon la réponse de l’utilisateur à une question.

En bash, les variables ne se déclarent généralement pas avant leur utilisation, on les utilise directement et elles sont créées lors de sa première mise en œuvre.

Pour pouvoir voir la valeur d’une variable il faut faire précéder son nom du caractère « $ ».

Exemple

#!/bin/sh
echo -n "Voulez-vous voir la liste des fichiers Y/N : "
read ouinon
if [ "$ouinon" = "y" ] || [ "$ouinon" = "Y" ]; then
{
    echo "Liste des fichiers :"
    ls -la
}
elif [ "$ouinon" = "n" ] || [ "$ouinon" = "N" ]; then
{
    echo "Ok, bye! "
}
else
{
  echo "Il faut taper Y ou N!! Pas $ouinon"
}
fi

Explication

Ce script peut paraître simple à première vue mais certaines choses prêtent à confusion et ont besoin d’être expliquées en détail.

Tout abord, le `echo -n` permet de laisser le curseur sur la même ligne, ce qui permet à l’utilisateur de taper la réponse après la question (question d’esthétique).

L’instruction `read` permet d’affecter une valeur ou un caractère à une variable quelconque, en la demandant à l’utilisateur. (NOTE: En bash, la variable est considérée comme une chaîne même si celle-ci contient une valeur numérique, et les majuscules sont considérées différente des minuscules, $M != $m).

Ensuite vient l’instruction conditionnelle `if`. Elle est suivie d’un « [ » pour délimiter la condition. Attention, la variable est mise entre guillemets car dans le cas où la variable est vide, le shell ne retourne pas d’erreur, mais en cas contraire, l’erreur produite ressemble à:

[: =: unaryoperator expected

L’opérateur `||` signifie « ou » (il existe aussi `&&` pour « et »). On peut définir une table de vérité pour ces deux opérateurs, où 1 représente une assertion vraie et 0 une assertion fausse :

Table de vérité de ||

Comparaison	Résultat	calcul
0 ou 0	0	0+0=0
0 ou 1	1	0+1=1
1 ou 0	1	1+0=1
1 ou 1	1	1+1=1

Dès que l’une des deux assertions est vérifiée, la condition globale l’est aussi.

Table de vérité de &&

Comparaison	Résultat	calcul
0 et 0	0	0*0=0
0 et 1	0	0*1=0
1 et 0	0	1*0=0
1 et 1	1	1*1=1

Les deux assertions doivent être vérifiées pour que la condition le soit aussi.

Enfin, on ferme le crochet, suivi d’un point virgule ou d’un saut de ligne pour exécuter la commande `then` qui applique ce qui vient après, si la condition est respectée.

Les « { » servent à bien délimiter le bloc d’instructions suivant le `then`, cela permet juste de facilement lire le code, de mieux se repérer.

Ensuite, `elif` sert à exécuter une autre série d’instructions, si la condition décrite par `if` n’est pas respectée, et si celle fournie après ce `elif` l’est.

Enfin, `else` sert à exécuter un bloc si les deux conditions précédentes ne sont pas respectées. (ah les jeunes, ils respectent plus rien de nos jours 🙂 ).

`fi` indique la fin de notre bloc d’instructions if, ce qui permet de voir où se termine toute notre portion de code soumise à une condition.

J’ai quelques petites commandes pratiques à vous donner :

sh -n nom_du_fichier

Cette commande vérifie la syntaxe de toutes les commandes du script, pratique quand on débute et pour les codes volumineux.

sh -u nom_du_fichier

Celle-ci sert à montrer les variables qui n’ont pas été utilisées pendant l’exécution du programme.

Voici le tableau des opérateurs de comparaison, ceux-ci peuvent s’avérer utiles pour diverses raisons, nous verrons un peu plus loin un exemple:

Opérateurs de comparaison

Syntaxe	Fonction réalisée
-e fichier	Vrai si fichier existe.
-d fichier	Vrai si fichier existe et est un répertoire.
-f fichier	Vrai si fichier existe et est un fichier ‘normal’.
-w fichier	Vrai si fichier existe et est en écriture.
-x fichier	Vrai si fichier existe et est exécutable.
f1 -nt f2	Vrai si f1 est plus récent que f2.
f1 -ot f2	Vrai si f1 est plus vieux que f2.

Exemple, vérifier qu’un fichier existe:

#!/bin/sh

echo -n "Entrez un nom de fichier: "
read file
if [ -e "$file" ]; then
{
        echo "Le fichier existe!"
}
else
{
        echo "Le fichier n'existe pas, du moins n'est pas dans le répertoire d'exécution du script"
}
fi
exit 0

La seule chose qui prête à confusion est que l’on vérifie seulement si le fichier ‘file’ est dans le répertoire où le script à été exécuté.

La commande `while`

La commande while exécute ce qu’il y a dans son bloc tant que la condition est respectée:

#!/bin/sh

cmpt=1
cm=3
echo -n "Mot de passe : "
read mdp

while [ "$mdp" != "ubuntu" ] && [ "$cmpt" != 4 ]; do
    echo -n "Mauvais mot de passe, plus que "$cm" chance(s): "
    read mdp
    cmpt=$(($cmpt+1))
    cm=$(($cm-1))
done
echo "Non mais, le brute-force est interdit en France !!"
exit 0

On retrouve des choses déjà abordées avec `if`. Le `&&` sert à symboliser un « et », cela implique que deux conditions sont à respecter. Le `do` sert à exécuter ce qui suit si la condition est respectée. Si elle ne l’est pas, cela saute tout le bloc (jusqu’a `done`). Je vous vois d’ici dire :

Mais qu’est-ce que c’est ce truc avec cette syntaxe zarbi au milieu ?

Cette partie du code sert tout simplement à réaliser une opération arithmétique. A chaque passage, ‘cmpt = cmpt+1’ et ‘cm = cm-1’.

`while` permet de faire exécuter la portion de code un nombre déterminé de fois. La commande `until` fait la même chose que la commande `while` mais en inversant. C’est a dire qu’elle exécute le bloc jusqu’a ce que la condition soit vraie, donc elle s’emploie exactement comme la commande `while`.

La commande `case`

Regardons la syntaxe de cette commande, qui n’est pas une des plus simples :

case variable in
  modèle [ | modèle] ...) instructions;;
  modèle [ | modèle] ...) instructions;;
    ...
esac

Cela peut paraître complexe mais on s’y habitue quand on l’utilise.

Mais a quoi sert cette commande ?

Elle sert à comparer le contenu d’une variable à des modèles différents. Les ;; sont indipensables car il est possible de placer plusieurs instructions entre un modèle et le suivant. Les ;; servent donc à identifier clairement la fin d’une instruction et le début du modèle suivant.

Exemple:

#!/bin/sh

echo -n "Etes-vous fatigué ? "
read on

case "$on" in
  oui | o | O | Oui | OUI ) echo "Allez faire du café !";;
  non | n | N | Non | NON ) echo "Programmez !";;
  * ) echo "Ah bon ?";;
esac
exit 0

Je crois que la seule chose qui mérite vraiment d’être expliquée est `* )`. Cela indique tout simplement l’action à exécuter si la réponse donnée n’est aucune de celle données précédemment.

Il existe aussi plusieurs structures pour les modèles, telles que:

case "$truc....." in
  [nN] *) echo "Blablabla...";;
  n* | N* ) echo "Bla....";;

Et plein d’autres encore…

On mélange tout ça

Pour vous donner une idée précise de ce que peuvent réaliser toutes ces instructions, j’ai fait un petit script censé refaire un prompt avec quelques commandes basiques :

#!/bin/bash

clear
echo 
echo #################### Script ############################
echo 
echo #############################
echo -n LOGIN: 
read login
echo -n Hôte: 
read hote
echo #############################
echo
echo ### Pour l'aide tapez help ###
echo 
while [ 1 ]; do                                 # permet une boucle infinie
echo -n ""$login"@"$hote"$ "                    # qui s'arrête avec break
read reps
case $reps in
 help | hlp )
   echo A propos de TS --> about
   echo ls --> liste les fichiers
   echo rm --> détruit un fichier (guidé)
   echo rmd --> efface un dossier (guidé)
   echo noyau --> version du noyau linux
   echo connect --> savoir qui est c'est dernièrement connecté;;
 ls )
   ls -la;;
 rm )
   echo -n Quel fichier voulez-vous effacer : 
   read eff
   rm -f $eff;;
 rmd | rmdir )
   echo -n Quel répertoire voulez-vous effacer : 
   read eff
   rm -r $eff;;
 noyau | "uname -r" )
   uname -r;;
 connect )
   last;;
 about | --v | vers )
   echo Script simple pour l'initiation aux scripts shell;;
 quit | "exit" )
   echo Au revoir!!
   break;;
 * )
  echo Commande inconnue;;
esac
done
exit 0

Remarque

Comme vous l’avez remarqué, l’indentation a une place importante dans ce programme. En effet, celui-ci est plus lisible et cela évite aussi de faire des erreurs. C’est pourquoi je vous recommande de bien structurer le code que vous écrivez.

La commande for

L’instruction `for` exécute ce qui est dans son bloc un nombre de fois prédéfini. Sa syntaxe est la suivante :

for variable in valeurs; do
  instructions
done

Comme vous l’aurez sans doute remarqué, on assigne une valeur différente à variable à chaque itération. On peut aussi très facilement utiliser des fichiers comme « valeur ». Rien ne vaut un exemple :

#!/bin/sh
for var in $(ls *.txt); do
  echo $var
done 
exit 0

On peut voir une syntaxe un peu particulière : `$(ls *.txt)`. Ceci sert à indiquer que ce qui est entre les parenthèses est une commande à exécuter.

On peut aussi utiliser cette instruction simplement avec des nombres, cela permet de connaître le nombre d’itérations :

#!/bin/sh
for var in 1 2 3 4 5 6 7 8 9; do
  echo $var
done 
exit 0

On peut très bien aussi utiliser d’autres types de variables, comme par exemple des chaînes de caractères :

#!/bin/sh
for var in Ubuntu Breezy 5.10; do
  echo $var
done 
exit 0

Il faut quand même faire attention au fait que Ubuntu Breezy 5.10 est différent de « Ubuntu Breezy 5.10 » dans ce cas. En effet, tous les mots placés entre «  » sont considérés comme faisant partie de la même chaîne de caractères. Sans les «  », sh considèrera qu’il y a une liste de trois chaînes de caractères.

Les fonctions

Les fonctions sont indispensables pour bien structurer un programme mais aussi pouvoir le simplifier, créer une tâche, la rappeler… Voici la syntaxe générale de ‘déclaration’ d’une fonction:

nom_fonction(){
instructions
}

Cette partie ne fait rien en elle même, elle dit juste que quand on on appellera nom_fonction, elle fera instruction. Pour appeler une fonction (qui ne possède pas d’argument, voir plus loin) rien de plus simple:

nom_fonction

Rien ne vaut un petit exemple:

#!/bin/sh

#Definition de ma fonction
mafonction(){
echo 'La liste des fichiers de ce répertoire'
ls -l
}
#fin de la définition de ma fonction

echo 'Vous allez voir la liste des fichiers de ce répertoire:'
mafonction       #appel de ma fonction
exit 0

Comme vous l’avez sans doute remarqué, quand on appelle la fonction, on exécute simplement ce qu’on lui a défini au début, dans notre exemple, echo… et ls -l, on peut donc faire exécuter n’importe quoi à une fonction.

Lien

Pour ceux qui souhaitent aller plus loin dans la conception de script shell, je vous recommande ce cours de chez developpez.com : http://marcg.developpez.com/ksh/

Bash parameters and parameter expansions. En anglais mais contient de nombreux exemples concernant la gestion et l’analyse des paramètres : http://www.ibm.com/developerworks/library/l-bash-parameters.html

Apprendre UNIX dans 10 minutes

Site original : http://freeengineer.org/learnUNIXin10minutes.html

Version en français : http://doc.ubuntu-fr.org/tutoriel/learn_unix_in_10_minutes

Avant Propos

Ce document a été rédigé il y a quelques années pour des étudiants en Dessin Assisté par Ordinateur (DAO) . Le but était d’avoir sur une page les commandes de base pour utiliser le Shell Unix (comme ça ils ne me demanderaient pas quoi faire lorsque quelqu’un leur donnerait une sauvegarde)

Ce document est copyrighté mais peut être reproduit selon les termes de la GFDL. Envoyez-moi vos commentaires, corrections ou tout autre ajout qui vous semble absolument nécessaire dans ce document.1)

Sections

Chemins

Les chemins de fichiers et de dossiers sous Unix utilisent le slash « / » pour séparer les noms des dossiers.

Exemples :

/	Dossier « racine »
/usr	Dossier usr (sous-dossier du dossier « racine »)
/usr/STRIM100	STRIM100 est un sous-dossier de /usr

Se déplacer dans le système de fichier

pwd	montre le nom du dossier de travail courant (Present Working Directory)
cd	change le dossier de travail pour un autre dossier
cd /usr/STRIM100	change le dossier de travail pour /usr/STRIM100
cd INIT	change le dossier de travail pour INIT, qui est un sous-dossier du dossier courant
cd ..	change le dossier de travail pour le dossier parent
cd $STRMWORK	change le dossier de travail pour le dossier défini par la variable d’environnement ‘STRMWORK’

Lister le contenu d’un dossier

ls liste le dossier de travail courant

ls -l dossier liste au format détaillé le dossier dossier

Par exemple :

 $ ls -l /home/sheherazade/work/
 drwxr-xr-x    4 sheherazade    staff     1024  2004-04-04 09:40 ToDo
 -rw-r--r--    1 sheherazade    staff    767392 2004-04-04 14:28 scanlib.tar.gz
 ^ ^  ^  ^     ^   ^             ^           ^      ^        ^      ^
 | |  |  |     |   |             |           |      |        |      |  
 | |  |  |     |  Propriétaire  Groupe      Taille Date     Heure  Nom 
 | |  |  |    Nombre de fichiers ou dossiers que le dossier listé contient
 | |  | Permissions pour tous
 | | Permissions pour les membres du groupe staff
 |Permissions pour le propriétaire  r = lecture (read), w = écriture (write), x = exécute (execute),  - = pas de droits
Type de fichier * : - = Fichier régulier, d = Dossier, l = Lien symbolique ou autre...

* Sous Unix tout est fichier

Modifier les permissions et les droits

chmod

En employant la méthode alphabétique:

Ce qu’il faut savoir:

• u: utilisateur (user), g: groupe (group) et o: autres (other)

• r: lire (read), w: écrire (write) et x: exécuter (execute)

 chmod [ugo][+-=][rwx] fichier

Vous devez donc choisir le groupe à modifier (u, g, o) suivis du symbole + pour donner une permission, du symbole – pour la retirer ou du symbole = pour définir la permission exacte suivi des permissions à appliquer (r, w, x).

Par exemple pour accorder à l’utilisateur d’exécuter le fichier.

 chmod u+x fichier

Ou pour retirer les droits d’écriture et d’exécution au groupe et aux autres.

 chmod go-wx fichier

En employant la méthode numérique:

Il faut savoir que x=1, w=2 et r=4 ensuite vous additionnez les chiffres si vous voulez cumuler les droits. L’ordre des chiffres est propriétaire/groupe/autres.

Par exemple pour accorder la lecture, l’écriture et l’exécution pour le propriétaire et la lecture et l’exécution pour le groupe et les autres.

chmod 755 fichier

On a propriétaire/groupe/autres donc rwx/rx/rx donc 4+2+1/4+1/4+1 et donc 7/5/5.

Astuce pour ceux qui connaissent le binaire. On veut rwx lire/écrire/exécuter donc 111 en binaire qui vaut 7 en décimal. On veut r-x lire/pas ecrire/exécuter donc 101 en binaire qui vaut 5 en décimal.

chgrp

chgrp staff fichier

change le fichier fichier afin qu’il appartienne au groupe staff.

chown

chown sheherazade fichier

fait de sheherazade la propriétaire du fichier fichier.

chown -R sheherazade dir

fait de sheherazade la propriétaire du dossier dir et de tous ses sous dossiers.

Vous devez être le/la propriétaire du fichier/dossier ou être root avant de taper ces commandes. Sous Ubuntu il faut les préfixer par sudo.

Déplacer, renommer et copier des fichiers

cp fichier_source fichier_destination	copie un fichier
cp -r dossier_source dossier_destination	copie un dossier
mv fichier1 nouveau_nom_fichier1	déplace ou renomme un fichier
rm fichier1 [fichier2 …]	supprime un fichier (ou une liste de fichiers) 2)
rm -r dossier1 [dossier2…]	supprime un dossier et tous ses sous-dossiers, à manier avec précaution
mkdir dossier1 [dossier2…]	crée un dossier
rmdir dossier1 [dossier2…]	supprime un dossier vide

Visualiser et éditer les fichiers

cat fichier	affiche le contenu du fichier à l’écran en ASCII
more fichier	affiche progressivement un fichier à l’écran : Entrer = descend d’une ligne, Espace = descend d’une page, q = quitte
less fichier	comme more, mais on peut utiliser la touche Page Précédente. Pas disponible sur tous les systèmes.
vi fichier	éditer un fichier avec l’éditeur vi. Tous les systèmes Unix ont un éditeur à la vi.
emacs fichier	éditer un fichier avec l’éditeur emacs. Pas disponible sur tous les systèmes.
head fichier	affiche les premières lignes d’un fichier
head -n fichier	affiche les n premières lignes d’un fichier
tail fichier	affiche les dernières lignes d’un fichier
tail -n fichier	affiche les n dernières lignes d’un fichier

Shells

Le comportement de l’interface en ligne de commande diffère légèrement en fonction du programme shell utilisé.

Suivant le shell utilisé, quelques comportements peuvent être pratiques.

Vous pouvez connaître le shell que vous utilisez avec la commande :

printenv SHELL

Vous pouvez bien évidemment créer un fichier contenant une liste de commandes shell et l’exécuter comme un programme pour exécuter une tâche. On appelle cela un script shell. C’est en fait le but premier de la plupart des shells, et non pas le comportement interactif de la ligne de commande.

Variables d’environnement

Vous pouvez apprendre au shell à ‘mémoriser’ des informations pour utilisation ultérieure grâce aux variables d’environnement. Par exemple avec bash :

export CASROOT=/usr/local/CAS3.0

définit la variable CASROOT avec la valeur /usr/local/CAS3.0.

cd $CASROOT

change le répertoire de travail courant pour CASROOT.

export LD_LIBRARY_PATH=$CASROOT/Linux/lib

définit la variable LD_LIBRARY_PATH qui prendra la valeur CASROOT avec /Linux/lib ajouté à la fin, c’est-à-dire /usr/local/CAS3.0/Linux/lib.

printenv

affiche toutes les variables d’environnement

printenv CASROOT

affiche la valeur de la variable d’environnement nommée CASROOT : /usr/local/CAS3.0.

echo $CASROOT

fait exactement la même chose.

Historique Interactif

Une fonctionnalité de bash et tcsh (et parfois d’autres) est de pouvoir utiliser la touche « flèche vers le haut » pour accéder aux dernières commandes entrées, les éditer, et les re-exécuter.

Complétion des noms de fichiers

Une des fonctionnalités de bash et tcsh (et probablement d’autres) est de pouvoir utiliser la touche TAB pour compléter un nom de fichier tapé partiellement. Par exemple, si vous avez un fichier nommé constantine-monks-and-willy-wonka.txt dans votre répertoire et si vous voulez l’éditer, vous pouvez taper ‘vi const’, enfoncer la touche TAB, et le shell va remplir le reste du nom pour vous (à condition qu’il soit unique).

Bash vous montre la voie

Bash complète aussi bien les noms de commandes que les variables d’environnement. En cas de possibilités multiples de complétion, taper deux fois sur la touche TAB vous montrera toutes les complétions possibles. Bash est le shell par défaut de la plupart des systèmes Linux.

Redirection

grep chaine fichier > nouveau_fichier

redirige la sortie de la commande précédente ‘grep’ dans un fichier nommé nouveau_fichier. Si nouveau_fichier existe il sera remplacé/ecrasé

grep chaine fichier >> fichier_existant

ajoute la sortie de la commande ‘grep’ à la fin du fichier fichier_existant.

Les opérateurs de redirection > et >> peuvent être utilisés sur la sortie de la plupart des commandes, pour les placer dans un fichier.

Pipes

Le symbole tube (« pipe ») « | » est utilisé pour rediriger la sortie d’une commande vers une autre.

Par exemple :

ls -l | more

Cette commande prend la sortie du listage au format long des fichiers dans un répertoire produit par « ls -l » et la redirige vers la commande « more » (aussi appelé filtre). Dans ce cas, une très longue liste de fichier peut être vue page par page.

Substitution de Commande

Vous pouvez utiliser le résultat d’une commande comme paramètre d’entrée pour une autre, en d’autres termes pour une substitution de commande. Une substitution de commande a lieu lorsque vous encadrez une commande avec des apostrophes inversées. Par exemple :

cat `find . -name aaa.txt`

va afficher à l’ecran (voir cat) le contenu de tous les fichiers nommés aaa.txt dans le dossier de travail courant ou ses sous-dossiers.

Rechercher une chaîne de caractères : La commande grep

grep chaine fichier

affiche toutes les lignes de fichier contenant chaine

Rechercher des fichiers : La commande find

Syntaxe :

find chemin -name fichier

find . -name aaa.txt

cherche les fichiers nommés aaa.txt dans le dossier courant ou ses sous-dossiers.

find / -name vimrc

cherche les fichiers nommés vimrc depuis le dossier racine

find /usr/local/games -name "*xpilot*"

cherche tous les fichiers dont le nom contient xpilot dans le dossier /usr/local/games

Créer des archives : La commande tar

La commande tar signifie ‘tape archive’ (archive sur bande). C’est la méthode ‘standard’ pour lire et écrire des archives.

Vous trouverez souvent des archives de fichiers avec des noms comme fichiers.tar, ou fichiers.tar.gz. Ce sont respectivement des fichiers dans une archive tar et des fichiers dans une archive tar qui a été compressée avec le programme de compression gzip.

Il est très probable, si quelqu’un vous envoie des fichiers, qu’ils soient compressés dans une archive tar.

De même, si vous devez envoyer des fichiers, vous devriez utiliser tar.

tar -xvf archive.tar	extrait les fichiers de l’archive archive.tar, en affichant les noms des fichiers qui la composent
tar -xvzf archive.tar.gz	extrait les fichiers de l’archive en utilisant gzip puis tar
tar -jxvf archive.tar.bz2	extrait les fichiers de l’archive en utilisant bzip2 puis tar
tar -cvf archive.tar fichier1 [fichier2...]	Crée un fichier « archive.tar » contenant fichier1, fichier2…
tar -cvzf archive.tar.gz mon_dossier	crée un fichier gzip contenant tout le contenu du dossier ‘mon_dossier’

Compression de fichier : gzip, bzip2

gzip

gzip est un outil GNU de compression et de decompression. L’extension pour les fichiers gzippés est .gz.

gzip fichier.txt	crée le fichier compressé fichier.txt.gz
gunzip fichier.txt.gz	extrait le fichier fichier.txt

bzip2

L’utilitaire bzip2 offre (en général) un meilleur taux de compression que gzip, mais au coût d’un temps de compression et décompression plus élevé.

bzip2 fichier.txt	crée le fichier fichier.txt.bz2
bunzip2 fichier.txt.bz2	décompresse le fichier fichier.txt.bz2.

Besoin d’aide : La commande man

La plupart des commandes ont une page de manuel qui donne une description de leurs utilisations plus ou moins détaillées, parfois utiles, parfois obscures. Certains disent qu’elles ont été appelées « man pages », parce qu’elles ne s’adressent qu’aux vrais Hommes.

Exemple:

man ls

affiche la page de manuel pour la commande ls

Pour obtenir des man pages en français :

sudo apt-get install manpages-fr

Commandes de base de l’éditeur Vi

Ouvrir un fichier

vi nom_du_fichier

Mode édition

i : insère avant le curseur

I : Insère au début de la ligne courante

a : insère après le curseur

A : insère à la fin de la ligne

r : remplace 1 caractère

R : passe en mode Remplacement\

<ECHAP> : met fin au mode Edition (insertion ou remplacement)

Effacer du texte

x : efface un seul caractère

dd : efface la ligne courante et la place dans un buffer

ndd : Efface n lignes (n est un nombre) et les place dans le buffer

J : déplace la ligne suivante à la fin de la ligne courante (effacement des caractères de retour chariot)

Oups

u : annule la dernière commande

Copier et coller

yy : copie la ligne courante dans le buffer

nyy : copie n lignes dans le buffer (n est un nombre)

p : colle le contenu du buffer après la ligne courante

P : colle le contenu du buffer avant la ligne courante

Positionnement du curseur

gg : va en haut de la page

G : va en bas de la page

:n : positionne le curseur à la ligne n

:$ : positionne le curseur à la fin de la ligne

^g : affiche le numéro de la ligne

h,j,k,l : respectivement gauche, bas, haut et droite ; les flèches de direction fonctionnent aussi…

Recherche de chaîne de caractères

/chaîne: recherche « chaîne ». n permet le passage à l’occurrence suivante. # permet de passage à l’occurrence précédente.

*: recherche avant de la chaîne de caractères présente sous le curseur.

#: recherche arrière de la chaîne de caractères présente sous le curseur.

Substitution de chaîne de caractères

:n1,n2:s/chaîne1/chaîne2/[g][c] : substitue chaîne1 pour chaîne2 sur les lignes n1 à n2. Si g est indiqué (global), toutes les références de chaîne1 sont remplacées, sinon seule la première référence est remplacée. Si c est indiqué (confirm), une confirmation sera demandée avant chaque modification.

^ : méta-caractère de début de ligne

. : méta-caractère, vrai sur n’importe quel unique caractère sauf retour chariot

$ : méta-caractère de fin de ligne

Ces caractères, tout comme les autres caractères spéciaux, peuvent être ‘échappés’ à l’aide du \ : c’est-à-dire pour capturer la chaîne de caractères « /usr/STRIM100/SOFT », il faut utiliser l’expression régulière « \/usr\/STRIM100\/SOFT »

Exemples:

:1,$:s/chien/chat/g

Remplace ‘chien’ par ‘chat’, pour chaque occurrence du fichier – de la ligne 1 à la fin du fichier ($)

:23,25:s/chien/chat/

Remplace ‘chien’ par ‘chat’ des lignes 23 à 25. Une fois par ligne, dès la première apparition.

Sauver, quitter et commandes d’exécution

Ces commandes sont toutes préfixées par les deux points (:) et apparaissent dans le coin inférieur gauche de la fenêtre.
Vous ne pouvez pas saisir ces commandes en mode édition. Appuyer sur <ECHAP> pour sortir du mode édition

:w : enregistre le fichier (Write)

:w nouveau.fichier : enregistre le fichier sous le nom ‘nouveau.fichier’

:wq : enregistre le fichier et quitte le programme

:q : quitte

:q! : quitte sans enregistrer les changements

:e fichier : ouvre ‘fichier’ pour l’édition

:set number : affiche les numéros de ligne

:set nonumber : cache les numéros de ligne

:set noai : désactive l’auto-indentation

dB ou non dB : les notions à savoir

Source : dB or not dB ?

Ce document contient:

1 Introduction………………………………………………………………………………….
2 Why use decibels in our calculations? …………………………………………….
3 Definition of dB…………………………………………………………………………….
4 What about dBm? ………………………………………………………………………..
5 What’s the difference between voltage decibels and power decibels?…
6 What is a level?……………………………………………………………………………
7 Attenuation and gain …………………………………………………………………….
Series connection of two-port circuits: ………………………………………..
8 Conversion from decibels to percentage and vice versa ……………………
Converting % voltage to decibels and vice versa………………………….
Converting % power to decibels and vice versa …………………………
Converting % voltage more or less to decibels…………………………..
Converting % power more or less to decibels…………………………….
9 Using dB values in computations ………………………………………………….
Adding power levels ……………………………………………………………….
Measuring signals at the noise limit ………………………………………….
Adding voltages……………………………………………………………………..
Peak voltages………………………………………………………………………..
10 Just what can we measure in decibels?…………………………………………
Signal-to-noise ratio (S/N)……………………………………………………….
Noise……………………………………………………………………………………
Averaging noise signals ………………………………………………………….
Noise factor, noise figure ………………………………………………………..
Phase noise ………………………………………………………………………….
S parameters ………………………………………………………………………..
VSWR and reflection coefficient ………………………………………………
Field strength ………………………………………………………………………..
Antenna gain …………………………………………………………………………
Crest factor …………………………………………………………………………..
Channel power and adjacent channel power ……………………………..
Modulation quality EVM…………………………………………………………..
Dynamic range of A/D and D/A converters ………………………………..
dB (FS) (Full Scale)………………………………………………………………..
Sound pressure level ……………………………………………………………..
Weighted sound pressure level dB(A) ………………………………………
11 A few numbers worth knowing ……………………………………………………..
Table for conversion between decibels and linear values…………….
Table for addition of decibel values…………………………………………..
Some more useful values ……………………………………………………….
Other reference quantities ………………………………………………………
Accuracy, number of decimal places ………………………………………..
12 Bibliography……………………………………………………………………………….
13 Additional information………………………………………………………………….

dB or not dB?
Everything you ever wanted to know
about decibels but were afraid to ask…

 

%, dB, dBm et dB (μV/m) sont des notions importantes pour les ingénieurs.

Quand il s’agit de l’écriture des formules et des unités, nous avons suivi le spécifié dans les normes internationales ISO 31 et CEI 27 (ou alors nous avons indiqué où il est de pratique courante de s’écarter de la norme).

 

Pourquoi utiliser des décibels dans nos calculs?

Les ingénieurs ont à traiter avec des chiffres sur une base quotidienne, et certains de ces chiffres peuvent être très grands ou très petits. Dans la plupart des cas, ce qui est plus important est le rapport de deux grandeurs. Par exemple, une radio mobile de station de base peut transmettre env. 80 W de puissance (gain d’antenne inclus). Le téléphone mobile ne reçoit que sur 0,000 000002 W, ce qui est
0,000 0000025% de la puissance transmise.
Chaque fois que nous devons traiter avec une large range numérique, il est commode d’utiliser le logarithme du nombre.

Par exemple, la station de base dans notre exemple transmet au +49 dBm tandis que le téléphone mobile reçoit -57 dBm, produisant un pouvoir différence de +49 dBm – (-57 dBm) = 106 dB.
Un autre exemple: Si nous cascade de deux amplificateurs de puissance avec des gains de 12 et
16, respectivement, on obtient un gain total de 12 x 16 = 192. En termes logarithmiques, les deux amplificateurs ont des gains de 10,8 dB et 12 dB, respectivement, la production d’un total gain de 22,8 dB, ce qui est certainement plus facile à calculer.
Quand on exprime en décibels, on peut voir que les valeurs sont beaucoup plus faciles à manipuler. Il est beaucoup plus facile d’ajouter et soustraire des valeurs en décibels dans votre tête. C’est la principale raison que nous aimons pour rendre nos calculs en décibels.

 

Définition de dB (décibel)

wikipédia : http://fr.wikipedia.org/wiki/D%C3%A9cibel

Atténuation et Gain

Si la puissance de sortie de P2 d’un circuit à deux ports est supérieure à la puissance d’entrée
P1, alors le ratio logarithmique de la P2 à P1 est positif. C’est ce qu’on appelle l’amplification ou gain.
Si la puissance de sortie de P2 d’un circuit à deux ports est inférieure à la puissance d’entrée P1,
Alors le ratio logarithmique de la P2 à P1 est négative. C’est ce qu’on appelle l’atténuation ou de la perte (le signe moins est omis).

Les amplificateurs classiques réalisent des gains de jusqu’à 40 dB en une seule étape, qui sont corresponds à la tension jusqu’à 100 ratios et les ratios de puissance jusqu’à 10000. Avec les valeurs plus élevées, il ya un risque d’oscillation dans l’amplificateur. Toutefois, un grand gain peut être obtenu en connectant plusieurs étapes en série. Le problème d’oscillation peut être évité par des mesures adéquates de protection.
La plupart ont des valeurs communes atténuateurs de 3 dB, 6 dB, 10 dB et 20 dB.
Ce ratio correspond à la tension de 0,7, 0,5, 0,3 et 0,1 ou de la puissance des ratios
0,5, 0,25, 0,1 et 0,01. Ici aussi, nous devons  de plusieurs atténuateurs en cascade pour obtenir des valeurs plus élevées. Si nous tentons d’obtenir une valeur plus élevés en une seule atténuation, il ya un risque de diaphonie.

Circuit intégré 2

Schéma simplifé un circuit intégré

Created by Pr. Michel ROBERT of LIRMM