Conky sous GNU/Linux

Bonsoir chers lecteurs, bonsoir Google Bot et autres.

Ce soir, un petit article sur conky, programme permettant d’afficher sur votre bureau divers informations concernant votre système, comme par exemple l’uptime de la machine, le % d’utilisation du CPU, l’utilisation de la RAM, l’occupation de vos disques durs ou encore, le titre de musique joué dans RhytmBox.

L’installation s’effectue via un simple sudo apt-get install conky. Il est parfois nécessaire de s’adapter, conky n’étant pas toujours disponible dans les dépôts de toutes les distributions GNU/Linux et il est parfois nécessaire d’ajouter des dépôts de type « non-free ». C’est le cas pour Debian, puisque conky est passé dans le dépôts « non-free » suite à une mise à jour. Néanmoins, l’installation reste à la portée de tous ;).

La configuration des informations à afficher est réalisée via le fichier .conkyrc situé dans votre home directory. Un Ctrl + H vous permettra de le rendre visible. Pour ceux qui n’ont jamais vu à quoi peut ressembler un conky, voilà le mien, remis en place ce soir et légèrement reconfiguré depuis sa dernière utilisation.

Pour ce qui est du code de configuration associé, le voici:

# set to yes if you want Conky to be forked in the background
background yes

cpu_avg_samples 2
net_avg_samples 2

out_to_console no

# Use Xft?
use_xft yes

# Xft font when Xft is enabled
xftfont Bitstream Vera Sans Mono:size=8

own_window        yes    # On dit à Conky de ne pas se mettre sur le bureau mais dans une fenêtre propre
own_window_type   override  # type de fenêtre "maison" (le type desktop convient si on n'a pas d'ombre)
own_window_hints  undecorated,below,sticky,skip_taskbar,skip_pager # définition du type
own_window_transparent yes
own_window_colour hotpink

# Text alpha when using Xft
xftalpha 0.8

on_bottom yes

# Update interval in seconds
update_interval 1

# Use double buffering (reduces flicker, may not work for everyone)
double_buffer yes

# Minimum size of text area
#minimum_size 280 5
#maximum_width 150

# Draw shades?
draw_shades no

# Draw outlines?
draw_outline no

# Draw borders around text
draw_borders no

# Stippled borders?
stippled_borders 10

# border margins
border_margin 4

# border width
border_width 1

# Default colors and also border colors
default_color white
default_shade_color white
default_outline_color white

# Text alignment, other possible values are commented
#alignment top_left
#minimum_size 10 10
gap_x 13
gap_y 34
alignment top_right
#alignment bottom_left
#alignment bottom_right

# Gap between borders of screen and text

# Add spaces to keep things from moving about?  This only affects certain objects.
use_spacer no

# Subtract file system buffers from used memory?
no_buffers yes

# set to yes if you want all text to be in uppercase
uppercase no

TEXT
$nodename - $sysname $kernel on $machine
$stippled_hr
${color lightgrey}Uptime:$color $uptime ${color lightgrey}- Load:$color $loadavg
${color lightgrey}CPU Usage:${color #5000a0} ${cpu}% ${cpubar}
${color black}${cpugraph 000000 5000a0}
${color lightgrey}RAM:$color $mem/$memmax - $memperc% $membar
${color lightgrey}Swap:$color $swap/$swapmax - $swapperc% ${swapbar}
${color lightgrey}Processes:$color $processes  ${color grey}Running:$color $running_processes

${color lightgrey}Temperatures:
 CPU:$color ${hwmon 0 temp 2}°C${color grey} - MB:$color ${hwmon 0 temp 1}°C

${color lightgrey}Batterie: $color${battery BAT0} ${battery_bar 5,120} ${battery_percent}%
$color$stippled_hr
${color lightgrey}File systems:
 /        $color${fs_used /}/${fs_size /} ${fs_bar 5,120 /}
$color$stippled_hr
${if_gw}${alignc}${gw_iface}: ${addrs eth0} Gateway: ${gw_ip}${endif}
Down ${offset 45}${totaldown eth0} ${offset 8}    Up ${alignr}${totalup eth0}
${downspeedgraph eth0 22,150 5e7b7b d8deeb} ${upspeedgraph eth0 22,150 99c8e8 618094}
${offset 40}${voffset -21}${downspeedf eth0}k/s
${offset 190}${voffset -14}${upspeedf eth0}k/s
$color$stippled_hr
${color}Name              PID     CPU%   MEM%
${color #ddaa00} ${top name 1} ${top pid 1} ${top cpu 1} ${top mem 1}
${color lightgrey} ${top name 2} ${top pid 2} ${top cpu 2} ${top mem 2}
${color lightgrey} ${top name 3} ${top pid 3} ${top cpu 3} ${top mem 3}
${color}Mem usage
${color #ddaa00} ${top_mem name 1} ${top_mem pid 1} ${top_mem cpu 1} ${top_mem mem 1}
${color lightgrey} ${top_mem name 2} ${top_mem pid 2} ${top_mem cpu 2} ${top_mem mem 2}
${color lightgrey} ${top_mem name 3} ${top_mem pid 3} ${top_mem cpu 3} ${top_mem mem 3}

${color #FFFFFF} ${top_mem name 1} ${top_mem pid 1} ${top_mem cpu 1} ${top_mem mem 1}
${color #FFFFFF} ${top_mem name 2} ${top_mem pid 2} ${top_mem cpu 2} ${top_mem mem 2}
${color #FFFFFF} ${top_mem name 3} ${top_mem pid 3} ${top_mem cpu 3} ${top_mem mem 3}
${color #FFFFFF} ${top_mem name 4} ${top_mem pid 4} ${top_mem cpu 4} ${top_mem mem 4}

${if_running rhythmbox}
${color lightgrey}${alignc}RhythmBox Now Playing :
${alignc}${exec rhythmbox-client --print-playing-format "%ta - %at"}
${alignc}${exec rhythmbox-client --print-playing-format "%tn - %tt"}
${endif}

La fenêtre ci-dessus ne pas très pratique pour la lecture, je mettrai certainement un lien vers le fichier. Pour lancer conky, taper conky dans un terminal. Dans mon cas, le résultat s’affiche en haut à droite de l’écran. A priori, le démarrage se fait automatiquement à l’ouverture de la session dans la dernière version grâce à l’appel du script .conkyboot.sh, situé dans le dossier .conky.

Algorithme de recherche des nombres premiers

Aujourd’hui, nous nous intéressons aux nombres premiers et à la façon de les trouver. Pour cela, voilà un algorithme assez simple qui permet de trouver un nombre n de nombre premier. Dans sa première version, l’algorithme recommençait à calculer à partir de 5 (si ma mémoire est bonne ;) ) à chaque exécution. Dans sa version actuelle, nous pouvons maintenant reprendre les calculs à partir du dernier nombre premier trouvé. Quelques améliorations pourront néanmoins être apporter comme la possibilité d’interrompre le programme alors qu’il teste des nombres et de le relancer sans avoir à repartir du dernier nombre premier, la gestion des grands nombres pourrait être à revoir. Nous pouvons également envisager la division du fichier contenant les nombres premiers en plusieurs autres fichiers tous les x nombres.

L’algorithme est présenté en code C et repose sur ce que mon professeur de sécurité désignait il y a quelques jours comme la « méthode naïve »; puisqu’il existe d’autres méthodes, permettant de s’assurer qu’un nombre n’est pas premier entre autres (mais pas d’équivalence ici, si le nombre n’est pas premier, le théorème ne permet pas de monter qu’il l’est) et dont je parlerais certainement dans un autre article.

Au jour d’aujourd’hui, notre fichier fait 969 376 620 octets et est trop grand pour être ouvert par certains éditeur de texte :D.  Pour déterminer si un nombre est premier, l’algorithme va regarder le résultat de la division du nombre testé par les nombres premiers déjà présent dans le fichier. Si le reste vaut 0, le nombre testé est divisible par un autre nombre que 1 ou lui-même, il n’est donc pas premier. On peut arrêter ce test, lorsque le nombre premier utilisé dans la division euclidienne est supérieur à la racine carré du nombre testé et ainsi gagner du temps. De même, l’incrémentation des nombres testés de 2 en 2 à partir d’un entier impair permet de ne jamais tester les nombres pairs puisque nous les savons tous divisibles par 2. Le lien vers un dossier contenant le code et les fichiers qu’il utilise: Algorithme Nombres Premiers. Place maintenant au programme:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int premier(int test);

int main(void)
{
    /*VARIABLE:
      recherche: le nombre de nombre premier à rechercher
      dernier: le dernier nombre testé
        lors de l'appel précédent au programme,
        contenu dans dernier.txt*/

    int recherche, dernier;
    FILE *fichier_dernier_nbr;
    FILE  *fichier;
    recherche=100;
    dernier=0;

    /*Initialisation du dernier nombre testé
      dernier est obligatoirement impair*/
    fichier=NULL;
    fichier_dernier_nbr = NULL;
    fichier_dernier_nbr = fopen("dernier.txt", "r+");

    if (fichier_dernier_nbr != NULL)
    {
        fscanf(fichier_dernier_nbr, "%d", &dernier);
        fclose(fichier_dernier_nbr);
    }

    /*On recherche autant de nombre premier
       que le contenu de recherche*/
    while(recherche>0)
    {
        if(premier(dernier))
        {
            /*Le nombre testé est premier*/
            /*printf("%d:Premier\n", dernier);*/
            /*On enregistre le nombre à la fin du fichier*/
            fichier = fopen("test.txt", "r+");
            fseek(fichier, 0, SEEK_END);
            fprintf(fichier, "%d\n", dernier);
            fclose(fichier);
            /*On décrémente le nombre de nombre premier
              encore à trouver*/
            recherche--;
        }
        dernier=dernier+2;
    }
    /*On enregistre le dernier à la fin du fichier*/
    fichier = fopen("dernier.txt", "w+");
    fseek(fichier, 0, SEEK_SET);
    fprintf(fichier, "%d", dernier);
    fclose(fichier);

    printf("Operation effectuee avec succes.\n");

    return EXIT_SUCCESS;
}

/*Renvoi 1 si le nombre est un nombre premier*/
int premier(int test)
{
    int nb_premier;
    int borne=0;

    FILE* fichier = NULL;
    fichier = fopen("test.txt", "r+");

    if (fichier != NULL)
    {

        while(feof(fichier)==0 && borne==0)
        {    
            fscanf(fichier, "%d", &nb_premier);
            /*printf("%d\n", nb_premier);*/
            /*Nombre divisible par un nombre premier,
              premier(test)=0*/
            if(test%nb_premier==0)
            {
                fclose(fichier);
                return 0;
                }
            /*Si la racine carré du nombre testé est inférieure au
              nombre premier actuel,inutile de continuer le test*/
            if(nb_premier>sqrt(test))
            {borne=1;}
        }

        fclose(fichier);
        if(borne==1)
        {return 1;}
    }
    return 0;
}

Illustration: illustrer.fr

Horloge Binaire Via Arduino + LoL Shield

Aujourd’hui, premier mars, je partage avec vous le code permettant l’affichage d’une horloge binaire sur votre LoL Shield contrôlé par Arduino. Cette horloge se divise en trois colonnes correspondant bien évidemment aux heures, minutes et secondes. Chaque colonne fait deux leds de large. Pour être correct, l’heure doit être initialisée à chaque fois que l’on relance le Arduino et il faut alors renvoyer le programme sur celui-ci. Il serait possible de synchroniser automatiquement l’horloge en se servant d’un shield Ethernet pour récupérer l’heure.

Quelques mots sur la fonction millis(). Cette fonction renvoie le nombre de millisecondes écoulées depuis que le Arduino a commencé à exécuter le programme en cours. Ce nombre revient à 0 après environ 50 jours. Ainsi, cette fonction va nous permettre d’incrémenter les secondes. Nous utiliserons le code suivant:

static unsigned long lastTick = 0;

if (millis() – lastTick >= 1000) {
 lastTick = millis();
 seconde++;}

Si le nombre de millisecondes depuis le début du programme moins le moment du dernier test est supérieur ou égale à 1 000, nous stockons le nombre de ms depuis le début du programme dans lastTick et nous incrémentons les secondes, dans le cas contraire, on ne change rien. Ainsi, toutes les 1 000 ms, les secondes seront incrémentées.

Pour la fonction LedSign::Set, la syntaxe est la suivante: LedSign::Set( C, L, E); . Avec C, le numéro de la colonne de la led concernée, L le numéro de la ligne et E l’état: 0 éteinte, 1 allumée. On a C = {0…13}, L = {0…8} et E = {0, 1}.

Voilà donc le code associé; la façon dont il est présenté ne me satisfait pas du tout. Pas évident d’afficher clairement du code avec WordPress…Donc finalement, j’ai trouvé un autre moyen, fournir le code directement dans un fichier texte: Horloge Binaire LoLShield

#include <avr/pgmspace.h>  //AVR library for writing to ROM
#include <Charliplexing.h> //Imports the library, which needs to be
//Initialized in setup.

void setup() {
  LedSign::Init();  //Initializes the screen
}

int seconde = 42;
int minute = 42;
int heure = 11;
int reste_heure,reste_minute, reste_seconde;

void loop() {
 static unsigned long lastTick = 0;

 //Incrémentation des secondes
 if (millis() - lastTick >= 1000) {
   lastTick = millis();
   seconde++;
 }


/*Remise à zéro des variables si celles-ci atteignent ou dépassent 60 pour les minutes et les secondes et 12 pour les heures.*/
 if(seconde >= 60) {
   minute++;
   seconde = 0;
 }

if(minute >= 60) {
 heure++;
 minute = 0;
}

if(heure >= 12) {
 heure = 0;
}

//calcul des leds allumées pour les heures
if(heure/8>=1) {
  LedSign::Set( 1, 5, 1);
  LedSign::Set( 2, 5, 1);
  reste_heure=heure%8;
} else {
  LedSign::Set( 1, 5, 0);
  LedSign::Set( 2, 5, 0);
  reste_heure=heure;
}

 if(reste_heure/4>=1) {
  LedSign::Set( 1, 6, 1);
  LedSign::Set( 2, 6, 1);
  reste_heure=reste_heure%4;
 } else {
  LedSign::Set( 1, 6, 0);
  LedSign::Set( 2, 6, 0);
 }

 if(reste_heure/2>=1) {
  LedSign::Set( 1, 7, 1);
  LedSign::Set( 2, 7, 1);
  reste_heure=reste_heure%2;
 } else {
  LedSign::Set( 1, 7, 0);
  LedSign::Set( 2, 7, 0);
 }

 if(reste_heure/1>=1) {
  LedSign::Set( 1, 8, 1);
  LedSign::Set( 2, 8, 1);
  reste_heure=reste_heure%1;
 } else {
  LedSign::Set( 1, 8, 0);
  LedSign::Set( 2, 8, 0);
 }

//calcul des leds allumées pour les minutes
 if((minute/32)>=1) {
  LedSign::Set( 6, 3, 1);
  LedSign::Set( 7, 3, 1);
  reste_minute=minute%32;
 } else {
  LedSign::Set( 6, 3, 0);
  LedSign::Set( 7, 3, 0);
  reste_minute=minute;
}

 if((reste_minute/16)>=1) {
  LedSign::Set( 6, 4, 1);
  LedSign::Set( 7, 4, 1);
  reste_minute=reste_minute%16;
 } else {
  LedSign::Set( 6, 4, 0);
  LedSign::Set( 7, 4, 0);
 }

 if((reste_minute/8)>=1) {LedSign::Set( 6, 5, 1); LedSign::Set( 7, 5, 1);reste_minute=reste_minute%8;} else {LedSign::Set( 6, 5, 0); LedSign::Set( 7, 5, 0);}

 if((reste_minute/4)>=1) {LedSign::Set( 6, 6, 1); LedSign::Set( 7, 6, 1);reste_minute=reste_minute%4;} else {LedSign::Set( 6, 6, 0); LedSign::Set( 7, 6, 0);}

 if((reste_minute/2)>=1) {LedSign::Set( 6, 7, 1); LedSign::Set( 7, 7, 1);reste_minute=reste_minute%2;} else {LedSign::Set( 6, 7, 0); LedSign::Set( 7, 7, 0);}

 if((reste_minute/1)>=1) {LedSign::Set( 6, 8, 1); LedSign::Set( 7, 8, 1);reste_minute=reste_minute%1;} else {LedSign::Set( 6, 8, 0); LedSign::Set( 7, 8, 0);}




//calcul des leds allumées pour les secondes
 if((seconde/32)>=1) {LedSign::Set( 11, 3, 1); LedSign::Set( 12, 3, 1);reste_seconde=seconde%32;} else {LedSign::Set( 11, 3, 0); LedSign::Set( 12, 3, 0);reste_seconde=seconde;}
 if((reste_seconde/16)>=1) {LedSign::Set( 11, 4, 1); LedSign::Set( 12, 4, 1);reste_seconde=reste_seconde%16;} else {LedSign::Set( 11, 4, 0); LedSign::Set( 12, 4, 0);}
 if((reste_seconde/8)>=1) {LedSign::Set( 11, 5, 1); LedSign::Set( 12, 5, 1);reste_seconde=reste_seconde%8;} else {LedSign::Set( 11, 5, 0); LedSign::Set( 12, 5, 0);}
 if((reste_seconde/4)>=1) {LedSign::Set( 11, 6, 1); LedSign::Set( 12, 6, 1);reste_seconde=reste_seconde%4;} else {LedSign::Set( 11, 6, 0); LedSign::Set( 12, 6, 0);}
 if((reste_seconde/2)>=1) {LedSign::Set( 11, 7, 1); LedSign::Set( 12, 7, 1);reste_seconde=reste_seconde%2;} else {LedSign::Set( 11, 7, 0); LedSign::Set( 12, 7, 0);}
 if((reste_seconde/1)>=1) {LedSign::Set( 11, 8, 1); LedSign::Set( 12, 8, 1);reste_seconde=reste_seconde%1;} else {LedSign::Set( 11, 8, 0); LedSign::Set( 12, 8, 0);}

}