lien : http://www.embedded.com/columns/guest/207402542?_requestid=825240

en français par google.translate: lien

Si les champions de Linux embarqué disent que Linux embarqué est terrible, pourquoi tout le monde veut risquer leur produits ou leur entreprise? [...]

If embedded Linux champions are saying that embedded Linux is terrible, why would anyone want to risk their products or their company on it?

Robert Anderson
Xilinx

This paper is the first in a three-part series describing techniques and methods for using MATLAB as an executable specification for hardware development. Why use MATLAB as an executable specification for hardware when other options exist such as Simulink, C, or RTL? The answer is verification. Because when the application is signal processing, MATLAB offers a vastly superior environment for input vector generation and output waveform analysis.

Using MATLAB allows the algorithm developer to create a model that more accurately describes the characteristics of the final hardware implementation. This flow enables the algorithm developer to reduce design iterations, shorten development cycles, and assert more control over the hardware development process.

Link: xilinx_matlab

Most signal processing and communication projects nowadays at some point require translating MATLAB code into equivalent C code. Goals and requirements of the resulting C code can be diverse. Examples include:

While C code requirements vary widely, some translation pitfalls are common across all applications and teams. Many of these pitfalls derive from the fact that MATLAB is essentially an interpreted language. Consequently, it does not require a priori knowledge. I.e., MATLAB doesn’t know the type, shape, dimension or even the existence of any variable or function until execution.

Let us list some of the most common or bothersome pitfalls:

• MATLAB indexes array elements starting with 1 whereas C indexing starts with 0
• MATLAB is column major whereas C is row major. This means consecutive data in MATLAB are column elements whereas consecutive data in C are row elements.
• MATLAB is inherently a vector-based representation. This can make the translation challenging. In particular:
  • You must replace the simplest vector operations with a loop construct
  • Operators (such as times ‘*’) in MATLAB perform different operations depending on the type of the operands
  • MATLAB includes very simple and powerful vector operations such as the concatenation “[]“and column “x(:)” operators or “end” construct, which can be quite hard to map to C
• MATLAB supports “polymorphism” whereas C does not. I.e., you can write a generic function in MATLAB, which can process different types of input parameters. In C, each parameter has one given type, which cannot change.
• MATLAB supports dynamic extensions and sizing of arrays, whereas C code requires storage to be allocated explicitly using malloc/free.
• MATLAB draws on a rich set of libraries that are not available in C. Implementing such functions requires writing new code. Sometimes there are pre-exiting libraries and functions available for your target platform, but integrating them into your application can be problematic. In addition to running into licensing issues (such using GPL code for commercial application), interfacing with these libraries is non-trivial.
• MATLAB supports reusing the same variable for different contents (different types). C does not, as each variable has one unique type.

As we will see, the process of writing C code from MATLAB is trickier than it sounds.

Preliminary step - What are my inputs?
When converting MATLAB to C, the first thing you need is a description of your function’s input parameters. This is because MATLAB, being an interpreted language, does not require declaration of data type for any variable.

Complicating matters, MATLAB variables have the following features not available in C

• The ability to have a variable number of parameters
• MATLAB data types that have no C equivalent, such as “cell arrays”, a collection of heterogeneous types packed into slices of an array

Typically, information about input parameters can be found in comments embedded at the top of the MATLAB function, or in a report written by the MATLAB code implementer.

Conversion Examples
With the input parameters defined, we can now turn to the MATLAB code itself. To illustrate some basic issues with translating MATLAB to C, we will show three examples, which we will translate by hand.

Example 1 – Simple(?) MATLAB code
Let’s start with a simple example. The MATLAB code below take in a vector ‘x’, and returns all but the first two values, sorted in ascending order, that are greater than a given threshold.

In MATLAB, this is an easy feat:

We can run it on a simple case:

Even such a trivial example, which does not make use of any advanced matrix or mathematical features of MATLAB, presents a number of problems for the C implementer:

An example implementation, as written in syntactically correct C, is shown below (where the “my_sort” function still has to be implemented):

We have only scratched the surface, but clearly, there is nothing obvious about translating such simple MATLAB code into C.

Example 2: Polymorphism
MATLAB does not require knowing the type of the input parameters. This means that one single function can be called with different arguments. Moreover, the times operator ‘*’ in MATLAB can perform a cross-product, a norm or an element-by-element multiplication depending on the operands, as shown below.

In this case, the function “polymorph” performs two very different computations to compute ‘a’ and ‘b’:

• for ‘a’, it computes the norm of the vector ‘x_complex_matrix’ which is +30.
• for ‘b’, it computes the sum of the multiplication of ‘x_complex_matrix’ with a scalar (’x_real_scalar’). The result is 12 -6i

We can run this function in MATLAB:

When translating this behavior to C, you are likely to want to write two completely different functions for “polymorph’.

Here is an example of how this function would look like in C, assuming we know that the input matrix has 10 elements.

(Click to enlarge)
Example 3: Dealing with unintended array expansion
One of our favorite (and real-life) examples is the unintentional expansion of a pre-defined array in MATLAB.

The story goes like this: the MATLAB designer thinks that array ‘x’ is 14-elements long. He declares it to be that way and never worries about whether this is actually the case or not. The C implementer, taking his word for it, declares ‘x’ to be ‘double[14]‘.

After countless simulations and week-ends spent debugging the mismatches between the MATLAB code and the C code, it turns out x was actually 15-long (in some exceptional case) and that the C code was reading in incorrect values.

MATLAB, indeed, lets you write statements such as:

If N turns out to be 15 at some point, you are not going to get any hint: “x” is going to be automatically extended to 15 elements. Not so in C, with the consequences mentioned above.

Part2:

Complex functions and C interfaces

In the first part of this series, we showed how basic MATLAB operations can be translated into C code. This section focuses on translating more complex MATLAB functions or toolbox functions into C, and on integrating C algorithms derived from MATLAB into your application.

Implementing complex MATLAB functions
Of the many MATLAB functions used to develop algorithms, most do not have equivalents in the C language. For example, the C language does not have equivalents for basic MATLAB functions such as “find” (which automatically extracts elements from an array) or “sort” (which sorts array elements).

Some of these functions are fairly well known and can be found in C libraries or on the Internet. For example, it is easy to find sorting algorithms. Nevertheless, finding the most efficient implementation for MATLAB’s sort function can be quite an adventure, as noted in this article.

In addition, you may not be able to use the functions you find due to license restrictions. These include license restrictions on derivative work from copyrighted material (such as MATLAB files) or open-source (GPL) files. In such case, you may need to carefully and independently recode the algorithms by hand for your commercial application.

When you implement a MATLAB function in a language such as C, you may find it difficult to replicate MATLAB’s results. For example, image processing applications may use morphology functions such as “imresize” to resize an image. When implementing such functions, it is easy to end up with results that are a fraction of a pixel off from MATLAB’s results. (Even MATLAB 2006b and 2007a produce different results for the “imresize” function because they implement it differently). To replicate MATLAB’s results, you may need to recalibrate your algorithm in C. This might add significant delay to your project.

Some functions have implementations in both MATLAB and C. The standard math C library can be used to implement functions such as divide, sqrt, cos, sin, etc. in C when dealing with real scalar data. Things get more complicated once you start adding complex numbers and matrices into the mix.

For example, the operation “a/b” may be look like a simple divide operator in MATLAB.

When the operands are complex scalars, the operation is slightly more complicated in C:

If b is a matrix, “a/b” becomes a “matrix divide,” which is a lot more complicated to implement. A “matrix divide” requires solving a linear system of equations consisting of finding ‘x’ such that “a*x=b”. This is typically performed using complex matrix manipulations based on matrix QR decompositions. An example of this approach is shown in Implementing matrix inversions in fixed-point hardware.

Integrating with other functions and interface definition
When translating a MATLAB algorithm to C, you may be able to re-use existing code or leverage functions available in libraries. Your task then is to integrate the C code derived from your MATLAB algorithm with existing source code and libraries. To make this integration successful you need to make sure the interfaces of your different functions are compatible. In particular, you need to pay special attention to conventions on how complex and multi-dimensional variables are laid out in memory, when data are passed by references and by value, and whether indices start from 1 or 0.

Indices start with 1 in MATLAB and 0 in C
One difference between MATLAB and C is that MATLAB uses one-base indexing whereas C uses zero-base indexing. This means that the index of the first element of an array in C is 0, and is 1 in MATLAB.

You need to be aware of this when communicating index values between C and MATLAB functions, otherwise you may end up addressing elements that are off by one in your final C code.

Consecutive array elements are stored in columns in MATLAB and in rows in C
MATLAB use column-major order, which mean column elements are stored next to each other in memory. In contrast, C uses row-major order, which means that row elements are stored next to each other. (See Wikipedia for details on the two array layouts.) Array layout is critical for correctly passing arrays between C and MATLAB functions. It is also important when accessing a specific data element using a single subscript ((*a)[i] instead of a[i][j]), or for traversing an array without cache misses for good performance.

If your NxM MATLAB array is implemented as an NxM array in C, you need to watch out for single subscripts. In the example below, the 7th element of the array cst in MATLAB is cst(7) that stores the value “4″. The 7th element of the array cst in C is cst[7-1] that stores the value “7″. To access the value “4″ in the C code, you would need to access cst[4-1]. As a result, when arrays are addressed with single-subscript expressions, you might have to add some extra computation in order to access the right location within your array.

(Click to enlarge)
Some algorithms such as symmetrical filters do not depend on the orientation of the data, which means they produce the same outputs when traversing data row by row or column by column. In this case, it is not necessary to recompute single subscript expressions in your C code.

If you want the data in the C code to be located at the same positions as in MATLAB, your other option is to map the NxM array in MATLAB into a MxN array in C. In the example below, the 7th element of the array is cst(7) in MATLAB and cst_rot[7-1] in C and they both store the value “4″. This requires rotating the data when interfacing with other C code that expects data to be stored in row-major order. An example of this approach is shown here.

(Click to enlarge)
Rotating data into and out of your function requires extra memory and copying. In many cases, it is more efficient to translate MATLAB’s column-major code into a row-major C code.

Dealing with Complex numbers
Support for complex data is built into MATLAB. For example, the result of an FFT is simply stored into a variable “y=fft(x)”. The implementation of the complex data type itself is abstracted away from the programmer. In contrast, ANSI-C does not have a built-in data type for complex numbers. (Complex data support has been added as part of the C99 standard.)

Typically, there are two ways of implementing complex arrays:

• Separate or split complex: the real part and imaginary part are stored into two separate arrays (e.g. separate a_real[0] and a_imag[0])
• Interleaved: the real and imaginary parts of a given array element are stored next to each other in memory (e.g. interleaved a[0] for the real part and a[1] for the imaginary part)

Much like with row-major vs. column-major, the decision on which implementation to use depends on how data is accessed in the algorithm and most importantly on how data is communicated to external functions.

MATLAB stores real and imaginary parts in separate arrays. This makes calls to the “real” and “imag” functions trivial to implement. On the other hand, many programming environments (including C99, FORTRAN, etc) and common libraries (Intel MKL, LAPACK, BLAS, FFTW, etc.) make use of the interleaved complex data type.

Translating split complex data into interleaved complex data requires extra memory and copies. If your algorithm often calls functions that are only available with interleaved complex data, it is more efficient to translate MATLAB’s split complex arrays into interleaved complex arrays in C.

Passing arrays by reference
MATLAB programmers typically do not have to worry about whether data are passed by reference or by value. Internally, all arrays in MATLAB are kept as “references” as long as their values remain unchanged. A local copy of the array is created as soon as a value within the array changes, in order to prevent unexpected side-effects.

To replicate this semantics in C, you need to copy data explicitly. As an example, if an array is the input of a function, it may only be passed by reference if that array does not get modified inside of the function.

MATLAB doesn’t explicitly support parameter passing by reference. However, an implicit convention is to use the same parameter names for both the input and output of the function to perform “in-place operations,” as illustrated in this blog. In C code, this can be accomplished by passing a pointer to the input parameter.

Interfacing with C libraries
The considerations presented in the previous sections apply to library functions as well as to functions that you implement yourself. For example, FFTW, LAPACK or the Intel Math Kernel Library all implement complex data as interleaved data. Data in LAPACK are passed in column-major format. FFTW, on the other hand, supports both row- and column-major formats.

Most libraries have specific memory allocation requirements on what data must be pre-allocated before the function is called, and freed after the function returns. The LAPACK library has the special property that all input, output or intermediary arrays must be pre-allocated by the caller of the library function and passed by reference. This way no dynamic memory allocation happens within the function called.

Some libraries even use specific memory allocators. For example, the FFTW library defines its own “fftw_malloc” function to guarantee that the returned pointer obeys the alignment restrictions imposed by the FFTW algorithm implementation.

In addition to constraints on the interfaces, the actual mapping between MATLAB functions and library functions is also non-trivial. Even though MATLAB makes use of both the LAPACK and FFTW libraries internally, these libraries do not have equivalent functions for operations such as matrix divide “mrdivide” or the FFT-based FIR filtering “fftfilt,” which is part of the signal-processing toolbox.

part 3: Code generation and verification

In the first two parts of this series, we navigated the waters of MATLAB to C translation and encountered some of the Charybdis and Scylla monsters that await the unsuspecting engineer along the way. By now, it should be plain indeed, that translating MATLAB to C, short of being a Homeric Odyssey, is anything but an easy task.

In this third and last part, we will explore verification and emphasize how automatic C code generation solves most of the issues described so far. We will illustrate this approach with Catalytic MCS (MATLAB to C Synthesis).

Making sure the C is correct
Verifying that the generated C code matches the original MATLAB code is both extremely important and challenging.

Thankfully, various techniques exist for such verification. A popular albeit tedious method consists of using files to pass input and output data, and comparing the results between the MATLAB code and C code. A more systematic method consists of turning the generated C code into a compiled MEX-file that can be called directly from MATLAB like any other function.

The mex command can be used from the MATLAB command line to compile C code into a MEX-file. The mex command uses the MEX API, which provides functions to pass data between your C code and MATLAB. The MEX-file guide provides more information on how to write your own MEX-files.

Turning your C model into a MEX-file allows you to rerun your original MATLAB simulation with no change and ensure the results are identical. However, you need to write a MEX wrapper function, which passes all the data you need to exchange between MATLAB and C. The wrapper uses arcane functions provided by the MEX-API. This task is also error prone—crashes, segmentation violations or incorrect results can easily occur if the MEX wrapper does not allocate and access the data properly.

The case for automation
Automating the generation of C code from the MATLAB file can help overcome these problems. Conceptually, an automated MATLAB-to-C converter offers the following advantages:

• The generated code is correct by construction
• The MATLAB and C code are always in-sync
• You can spend more time in MATLAB developing and tuning your algorithms rather than writing and debugging low-level C-code
• Updates to the algorithms result in automatic, immediate update of the C code

However, automatic translation of MATLAB code to C code raises a few important questions:

• How powerful is the set of MATLAB commands that can be translated to C? The solution loses much of its appeal if it requires the algorithm designer to restrict his style drastically. The designer must then heavily rewrite his MATLAB code, a time-consuming and error prone process. Furthermore, the code loses a lot of its flexibility.
• How efficient is the generated code? Are advanced techniques for memory management and C-code optimization available?
• Does the generated C-code easily interface with the existing code for your application?
• How readable is the resulting C code? Is the C-code understandable and maintainable? Does the generator retain the structure of the original MATLAB file?
• Can the code generator target specific libraries for a given application?

We will review all these pitfalls when looking at Catalytic MCS. But note that code generation from MATLAB isn’t a new concept, although it has received limited attention.

The AccelDSP tool from Xilinx targets the FPGA market with Verilog/VHDL code generation from MATLAB. (For a related how-to article, see Generate FPGA designs from M-code.) This tool relies heavily on library modules to obtain the highest quality results out of a quantized design.

More recently, The Mathworks introduced a restricted subset of the MATLAB language called “Embedded MATLAB,” for which Real-Time Workshop can generate C code. The subset is aimed at addressing the needs of embedded designers, who do not perform algorithm exploration or mind restricting their MATLAB style for an embedded target. In particular, Embedded MATLAB avoids a lot of the issues described in the previous two parts of this series by requiring rewrite of the MATLAB in Embedded MATLAB.

In the remainder of this article, we’ll demonstrate how you can use Catalytic MCS to generate high quality, flexible C code from existing MATLAB code, which was written by algorithm experts without consideration for matrix size or type declaration.

Preview of a better way…
This part highlighted some of the pitfalls in developing MATLAB library functions in C and interfacing these functions with external functions or libraries.

Part 3 of this article will present how Catalytic MCS can automatically generate C code from MATLAB that is easy to integrate with other C functions and that interfaces common libraries automatically. In addition, the Catalytic Function Library makes it possible to automatically generate functionally-equivalent C code for many MATLAB functions.

About the authors
Marc Barberis leads the applications group at Catalytic Inc. Prior to Catalytic, he held several positions in wireless design and system level simulation tools . His interests include physical layer for 3G and digital receiver algorithms. Marc holds a MS in EE from Ecole Nationale Superieure des Telecommunications de Paris. He can be reached at marc@catalyticinc.com.

Luc Semeria is product manager at Catalytic Inc. Prior to Catalytic, he held several positions at Synopsys Inc. His research interests include compilers, EDA tools, computer architecture, and DSP algorithms. Luc holds a Ph.D. in Electrical Engineering from Stanford University. He can be reached at luc@catalyticinc.com.

Related articles:

• One-button MATLAB-to-C conversion
• MathWorks rolls MATLAB C generator
• Accelerating MATLAB using MEX-files
• Unite algorithm and hardware design flows
• Languages for Signal Processing Software Development
• Automated video algorithm implementation

Lien : http://systeme.developpez.com

Vous cherchez

Architecture des ordinateurs
Systèmes d’exploitation
Systèmes temps réels
Systèmes embarqués
Systèmes répartis
Réseaux : Généralités
Réseaux : Bus
Parallélisme
Grilles de calcul
Sécurité
Compression audio et vidéo

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.

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.

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 :

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 :

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

Présentation

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

Ecrire un script

#!/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

Exécuter un script

bash nom_du_script

chmod +x nom_du_script

./nom_du_script

Les différents types de shells

Les structures de contrôle

Les tests : `if`

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

[: =: unaryoperator expected

Table de vérité de ||

Table de vérité de &&

sh -n nom_du_fichier

sh -u nom_du_fichier

Opérateurs de comparaison

#!/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 commande `while`

#!/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

La commande `case`

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

#!/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

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

On mélange tout ça

#!/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

La commande for

for variable in valeurs; do
  instructions
done

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

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

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

Les fonctions

nom_fonction(){
instructions
}

nom_fonction

#!/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

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

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

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

Avant Propos

Sections

Chemins

Se déplacer dans le système de fichier

Lister le contenu d’un dossier

 $ 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...

Modifier les permissions et les droits

chmod

En employant la méthode alphabétique:

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

 chmod u+x fichier

 chmod go-wx fichier

En employant la méthode numérique:

chmod 755 fichier

chgrp

chgrp staff fichier

chown

chown sheherazade fichier

chown -R sheherazade dir

Déplacer, renommer et copier des fichiers

Visualiser et éditer les fichiers

Shells

printenv SHELL

Variables d’environnement

export CASROOT=/usr/local/CAS3.0

cd $CASROOT

export LD_LIBRARY_PATH=$CASROOT/Linux/lib

printenv

printenv CASROOT

echo $CASROOT

Historique Interactif

Complétion des noms de fichiers

Bash vous montre la voie

Redirection

grep chaine fichier > nouveau_fichier

grep chaine fichier >> fichier_existant

Pipes

ls -l | more

Substitution de Commande

cat `find . -name aaa.txt`

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

grep chaine fichier

Rechercher des fichiers : La commande find

find chemin -name fichier

find . -name aaa.txt

find / -name vimrc

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

Créer des archives : La commande tar

Compression de fichier : gzip, bzip2

gzip

bzip2

Besoin d’aide : La commande man

man ls

sudo apt-get install manpages-fr

Commandes de base de l’éditeur Vi

Ouvrir un fichier

vi nom_du_fichier

Mode édition

Effacer du texte

Oups

Copier et coller

Positionnement du curseur

Recherche de chaîne de caractères

Substitution de chaîne de caractères

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

:23,25:s/chien/chat/

Sauver, quitter et commandes d’exécution

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 …………………&