Installer le driver nVidia le plus récent sur FreeBSD

FreeBSD 9.1 fraîchement installé sur mon ordinateur principal, je me dis qu’il faudrait y mettre les drivers pour ma carte nVidia GT 430. Certes mais comment faire ?

Je suis donc allée voir la documentation où j’apprends que l’opération est très simple via le système de ports FreeBSD (pour ceux qui ne connaissent pas, c’est ici).

En bonne débutante, je fais ce qu’on me dit donc je vais dans le répertoire « /usr/ports/x11/nvidia-driver » et je lance la compilation via « make install clean« .

Et là what ??? Il va sur le site de nVidia (rien de choquant) pour me télécharger la version 304.64. C’est le numéro de version qui m’a perturbé, j’avais été faire un tour sur le site de nVidia la veille et j’avais vu une version plus récente. Mince mon catalogue de logiciels portés est pourtant bien à jour :S. Et là têtue comme je suis, j’ai voulu avoir les derniers drivers donc j’ai fait un petit Ctrl-C :D . Voici comment je m’y suis prise pour installer les derniers drivers.

Mettre à jour le makefile :

Tiens, un petit tour dans le Makefile, rien de compliqué dans le contenu et puis je trouve directement une variable avec le numéro de version que je ne veux pas. Je mets donc la variable du Makefile à jour comme suit :

DISTVERSION=    310.19

Juste ça ? Trop facile !! Non, perdu, il faut aussi mettre à jour un autre fichier :D sinon vous allez avoir une erreur vous indiquant que votre fichier « distinfo » n’est pas à jour car il ne contient pas le numéro de version demandé.

Mettre à jour le fichier distinfo :

Le fichier « distinfo » contient 2 informations sur le fichier à télécharger la somme SHA256 (pour vérifier l’intégrité à la fin du téléchargement) et sa taille.

Pour avoir ces informations,j’ai donc téléchargé la version trouvée sur la page officielle des drivers Unix de nVidia.

Pour la somme SHA256 du fichier, il y a une commande toute faite :

sha256 NVIDIA-FreeBSD-x86_64-310.19.tar.gz

La taille s’obtient en en utilisant la commande « stat » sur l’archive téléchargée.

stat NVIDIA-FreeBSD-x86_64-310.19.tar.gz | cut -d ' ' -f8

Vous pouvez directement faire une redirection (en ajout bien sûr …) du résultat de ces commandes dans le fichier « distinfo », puis il faudra modifier/ajouter les deux dernières lignes comme suit :

SHA256 (NVIDIA-FreeBSD-x86_64-310.19.tar.gz) = sha_obtenu
SIZE (NVIDIA-FreeBSD-x86_64-310.19.tar.gz) = taille_obtenue

Et voilà, vous pouvez ensuite faire comme indiqué dans le manuel :

cd /usr/ports/x11/nvidia-driver
make install clean

C’est fini pour aujourd’hui. Je profite de cet article pour vous souhaiter une très bonne année 2013.

Consommation CPU & RAM sous Linux et Solaris

Si vous avez un jour besoin de connaître le pourcentage de CPU et la quantité de RAM utilisé sous Solaris ou Linux et de réutiliser ces données dans un script, vous trouverez dans ce petit article votre bonheur.

Récupérer le pourcentage de CPU utilisé :

Sous Linux, je propose la commande suivante :

CPU=`vmstat | tail -n 1 | awk '{printf(100-$(NF-1))}'`

 Tandis que sur Solaris, je propose plutôt celle-ci :

CPU=`vmstat | grep "[0-9]\{2\}" | tail -n 1 | awk '{printf(100-$(NF))}'`

Récupérer la RAM consommée (en Mo) :

Sous Linux, je propose la commande suivante :

RAM=`free -m | head -n 2 | tail -n 1 | awk '{printf($3)}'`

Tandis que sur Solaris, je propose cette longue alternative :

let RAM=`prtconf | grep Memory | awk '{print $3}'`-`vmstat | grep "[0-9]\{2\}" | awk '{printf("%d",($5/1024))}'`

Je ne dis pas que c’est LA manière de faire, mais c’est en tout cas une technique qui fonctionne. Si vous avez des suggestions, je pense surtout pour Solaris, n’hésitez pas, les commentaires sont là pour ça.

Commenter des lignes dans Vim

Vous le savez bien, je ne suis pas une grande fan de l’éditeur Vi mais bon il arrive parfois que cet outil soit le seul éditeur disponible sur une plate-forme Unix.

Bref, je me baladais dans les scripts que j’avais déployé sur une machine Solaris (l’un de ces OS où Vi est votre ami) et je me suis rendu compte que j’avais oublié de commenter 4 petites lignes dans mon fichier ksh.

Plutôt que de commenter ligne par ligne, je me suis dit : « Allez, prenons-nous au jeu et trouvons un raccourci pour commenter en un seul coup les 4 lignes ! ».

C’est en fait plutôt simple et logique, voici comment faire :

  1. Créez un fichier texte avec plusieurs lignes ou ouvrez-en un,
  2. Sélectionnez les premières lettres de chaque ligne à commenter grâce à Ctrl+V et les touches directionnelles Haut et Bas.
  3. Appuyez sur « Shift+i » (donc I) pour passer en mode insertion,
  4. Tapez # ou // selon le type de commentaire voulu,
  5. Appuyez sur Echap.

Et là, viaillesque magie, vos lignes sont commentées :-) .

Notez d’ailleurs que ce raccourci ne sert pas qu’à commenter, il permet d’insérer en début de chaque ligne un caractère ou un mot.

Marque-pages

S’il vous arrive un jour de gérer un ensemble d’utilisateurs et leur environnement de travail reposant sur Gnome, vous vous demanderez probablement comment ajouter automatiquement des raccourcis vers des répertoires de travail différents des habituels Images, Musique …

Je me suis posée cette question récemment et la réponse était très simple. Il suffit de modifier le fichier « .gtk-bookmarks » se trouvant à la racine du répertoire home d’un utilisateur.

Par exemple, vous pouvez voir ici un exemple quand j’ai ajouté mon répertoire de développement à la liste des signets :

Si je n’avais pas précisé « Dev », le nom de mon signet aurait alors été « Devs » le nom du répertoire se trouvant en fin de chemin.

Le gros avantage de ce fichier réside dans le fait qu’il est utilisé par Ubiquity (le gestionnaire de bureau d’Ubuntu), Gnome et XFCE (et peut-être même d’autres environnements).

P.S: Cet article est rédigé depuis plus d’un mois mais j’avais oublié de le publier ^_^ ».

Masquer l’identité de votre serveur Lighttpd

Si comme moi vous avez opté pour un serveur moins « mainstream » que le serveur web Apache et que vous souhaitez masquer le fait que vous utilisez lighttpd (lighty pour les intimes) ou que vous voulez carrément faire croire que vous utilisez Apache (exemples parmi tant d’autres), vous pouvez le faire en une ligne !

Dans votre fichier de configuration lighttpd (généralement dans /etc/lighttpd/lighttpd.conf), définissez ou modifiez la valeur du paramètre server.tag.

server.tag = "Valeur désirée"

Et voilà, redémarrez Lighty et constatez le changement. Ci-après un screenshot de mon serveur où l’on voit que la valeur habituelle a été changée en « Personnal Web Server ».

lighty

Pour les anciens habitués du blog, désolé pour l’absence de mises à jour depuis quelques temps, j’essaye d’y remédier ;-) . A bientôt !

Utilisation de glPolygonStipple

C’est parti pour le premier article technique de cette année.

Comme vous le savez j’apprends l’OpenGL avec le livre officiel dans sa septième édition. Pour le moment, je n’ai lu que 1/10ème du livre en question. Mais je dois reconnaître que ce livre regorge d’informations mais elles sont parfois trop peu approfondies. Je vais donc par le biais de ce post vous présenter la fonction glPolygonStipple qui vous permettra d’appliquer des textures sur différentes surfaces.

Pour faire simple, j’ai opté pour un dessin simple: un smiley. Le but de cet article va donc être d’appliquer une texture sur une surface 2D classique: glRectf.

Mais avant de nous jeter dans le code, il faut tout d’abord savoir ce que va faire notre programme :

  1. Initialisation d’OpenGL et définition du repère de travail
  2. Création d’un tableau de byte représentant notre smiley
  3. Appliquer notre smile sur un glRectf

Pour ce qui est de la première étape d’initialisation d’OpenGL et du repère, il suffit de saisir les lignes suivantes :

/*Define the drawing zone properties*/
void init(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_FLAT);
glViewport(0, 0, 10, 10);

//Load identity matrix
glLoadIdentity();

//Define x & y axis
gluOrtho2D((GLdouble) -10, (GLdouble) 10, (GLdouble) -10, (GLdouble) 10);
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(640, 480);
glutInitWindowPosition(1024,100);
glutCreateWindow("OpenGL GLubyte Demo");

init();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

Voilà, ce code est assez classique rien d’extraordinaire à expliquer et puis je l’ai déjà fait dans un post précédent. Nous allons pouvoir directement passer à la seconde étape, celle qui nous intéresse le plus: la création du smiley.

Pour ma part, j’utilise un tableur comme celui d’OpenOffice.org pour modéliser le smiley et en faire le découpage en tableau de bytes.

Faîtes une grille de 32×32 soit 1024 cases. Arrangez-vous pour ne pas faire des cases trop grandes et de forme carrée pour que cela tienne sur votre écran (bon effectivement si vous avez un 14″ ça va être dur … :p). Une fois les cases dessinées faites des bordures plus épaisses sur des rectangles de 8×4 (Longueur x Hauteur) pour avoir 4 colonnes (si si je vous assure 4×8 ça fait 32). Pour dessiner notre smiley, il suffit de noircir les cases de la grille pour que l’ensemble ressemble à un smiley.

Comme je suis sympa, vous pouvez prendre mon modèle au format ODS ici.

Vous devriez donc avoir un smiley ressemblant à celui-ci :

Si vous avez téléchargé mon fichier ODS, vous savez ce que nous allons faire: traduire notre smiley en byte. Mais comment faire !? J’ai eu du mal à trouver mais c’est en fait très simple. Il suffit de connaître le principe et ça se fait très vite. Zoomons sur la première partie de l’œil :

Chaque case de dimension 8×4 va vous donner 4 valeurs hexadécimales (une pour chaque ligne) que nous reporterons dans un tableau. La première case de droite vaut 1, la suivante 2, puis 4 et ainsi de suite jusqu’à la dernière qui vaut 80 (128 en décimal). Ici, nous aurons donc les valeurs 0, 0, 1, 3. Je vous laisse vous entrainer avec les autres cases. Si vous avez pris le même exemple que moi, vous avez les valeurs suivantes (à partir du coin de l’œil ci-dessus): 1, 80, 1, 80, 3, C0, 3, C0, 3, C0, 3, C0, 1, 80, 1, 80, 0, 0, 80, 0, … 0, 0E, 70, 0, 0, 3, C0, 0 …

Seulement voilà, si nous utilisions ces valeurs dans notre programme nous aurions un smiley à l’envers car la fonction glPolygonStipple se base sur les bits de poids forts. Ils faut donc inverser chaque groupe de 4 valeurs (les lignes de notre grille) et nous pourrons retourner à notre code. Les valeurs seront donc les suivantes : 0, 3, C0, 0, 0, 0E, 70, 0, …, 0, 0, 80, 0, 1, 80, 1, 80, 3, C0, 3, C0, 3, C0, 3, C0, 1, 80, 1, 80 …

Le plus gros du travail est maintenant terminé, il nous reste à écrire notre fonction display() :

/*Display function*/
void display(void)
{
    glClear(GL_COLOR_BUFFER_BIT);

    glColor3f(1.0, 1.0, 1.0);

    //Our values from the previous step
    GLubyte smile[] = {
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x03, 0xC0, 0x00,
        0x00, 0x0E, 0x70, 0x00,
        0x00, 0x18, 0x18, 0x00,
        0x00, 0x20, 0x04, 0x00,
        0x00, 0x40, 0x02, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x02, 0x00, 0x00,
        0x00, 0x01, 0x00, 0x00,
        0x00, 0x01, 0x00, 0x00,
        0x00, 0x01, 0x00, 0x00,
        0x00, 0x01, 0x00, 0x00,
        0x00, 0x01, 0x00, 0x00,
        0x00, 0x00, 0xC0, 0x00,
        0x01, 0x80, 0x01, 0x80,
        0x03, 0xC0, 0x03, 0xC0,
        0x03, 0xC0, 0x03, 0xC0,
        0x01, 0x80, 0x01, 0x80,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00
    };

    glEnable(GL_POLYGON_STIPPLE);

    glPolygonStipple(smile);
    //Define the surface where we apply our texture
    glRectf(10, -10, -10, 10);

    glDisable(GL_POLYGON_STIPPLE);
    glFinish();
}

C’est ici que l’on se rend vraiment compte de l’intérêt du fonctionnement interne d’OpenGL comme une machine à états. La fonction glEnable() permet d’activer GL_POLYGON_STIPPLE en mémoire, d’exécuter la fonction glPolygonStipple() avec les valeurs obtenues à l’étape précédente, d’appliquer notre « tapisserie » sur le glRectf. Une fois que l’on en a plus besoin, on désactive GL_POLYGON_STIPPLE ce qui permet de vraiment optimiser les traitements et la mémoire.

Et voilà, c’est fini ! Vous pouvez compiler votre code est admirer votre travail :

J’espère que cette première partie vous a plu.

A bientôt pour opengellesques aventures ;-) .

Régler le volume du son sur Linux via SSH

Dans la lignée des astuces bien utiles mais dont on a rarement l’utilité (sic), voici comment augmenter ou diminuer le son sous Linux via SSH.

Une fois que vous êtes connecté via SSH à votre machine distante, il faut utiliser le gestionnaire de son Alsa (Alsa Mixer in english :p). Comment ?

C’est très simple, il suffit d’utiliser la commande amixer avec les bons paramètres.

Par exemple pour lister les différents contrôleurs disponibles, vous taperez la commande « amixer scontrols ».

Personnellement, j’ai eu besoin de modifier le son PCM de la carte donc j’ai procédé comme cela :

amixer

La commande « amixer get ‘PCM’ » permet d’afficher les informations actuelles et pour augmenter le volume (ici passage de 10% à 70%), on utilise la commande « amixer set ‘PCM’ 70% ».

Je ne pense pas que cette méthode fonctionne sur les versions récentes de Ubuntu car je crois qu’elles utilisent PulseAudio à la place de Alsa. N’hésitez pas à me dire si ça marche quand même !

Bonne semaine à tous !

OpenGL & MacOS X

Si vous aussi vous avez déjà tenté de développer une application OpenGL sous Mac OS X, vous avez dû être surpris de constater que votre programme refusait de compiler.

En fait, j’ai trouvé 2 méthodes pour pouvoir compiler correctement vos programmes OpenGL.

La première méthode ne nécessite aucune modification du code mais une fois compilée, l’application se lancera dans X11. Pour cela, il suffit de compiler avec les paramètres suivants :

gcc main.c -o testmacx11 -I/usr/X11R6/include -L/usr/X11R6/lib -lGL -lglut

Ici, nous compilons main.c pour qu’il donne le binaire testmacx11 en lui indiquant le chemin vers les includes et les libs de X11.

L’exécution de testmacx11 provoquera le lancement de X11 puis seulement de votre application.

La deuxième méthode consiste, vous l’aurez deviné, à lancer l’application finale avec Cocoa. Pour celà, il faut tout d’abord modifier le code. Pour conserver l’interopérabilité du code et ne pas avoir à le modifier à chaque changement de système d’exploitation, on utilise la directive conditionnelle #ifdef pour déterminer si l’on est ou non sur un Mac. Selon la plateforme, on met les bons headers :

#ifdef __APPLE__
#include <OpenGL/gl.h>
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glut.h>
#endif

Une fois cette modification de vos sources réalisée, nous allons donc compiler à la mode Mac OS X :

gcc main.c -o testmacocoa -framework GLUT -framework OpenGL -framework Cocoa

Et voilà, quand vous lancez votre application via testmacocoa, celle-ci se lance comme une application MacOS classique.

Enfin, je trouve quand même que la compilation sous Linux est plus aisée :

gcc main.c -o testlinux -lglut

J’espère que ce post vous aidera grandement ;-) .

Premiers pas avec OpenGL

Aujourd’hui, j’ai eu l’occasion de faire mes premiers pas en OpenGL avec du C bien sûr. Voici donc mes premières impressions.

Tout d’abord, avant de commencer à développer, il a fallu que je trouve des documents sur le net. Le site de NeHe est assez réputé, l’adresse de son site est même présente dans le topic du chan ##OpenGL sur Freenode. Eh bien je trouve que pour débuter, son site est très loin d’être le bon endroit. Je m’attendais à beaucoup mieux et l’horrible design qui vous explose les yeux au bout d’un quart d’heure a eu raison de moi.

J’ai donc essayé de trouver d’autres ressources. Et là, je suis tombée sur une très bonne ressource qui vous explique bien les bases: The OpenGL Programming Guide. La ressource en question est en anglais mais est écrite dans un style didactique clair. Mais bon, je suis quand même surprise de constater que les ressources pour apprendre l’OpenGL sont super rares.

Ensuite, après avoir lu l’introduction du site sus-cité, j’ai donc voulu tester le premier code fournit en exemple. Et là, deuxième surprise: MacOS n’utilise pas les mêmes headers concernant OpenGL. Mac OS est vraiment la pire plateforme de développement que j’ai pu tester, même Windows s’en sort mieux face à ce genre de situation… Enfin bref, j’ai donc fait mes premiers tests sur Ubuntu sans aucun problème.

Niveau programmation, je trouve que l’API OpenGL et ses spécifications sont vraiment claires. Je ne regrette pas d’avoir un peu galéré pour découvrir une telle technologie :-) . Un grand merci au Khronos Group. Étant donné la puissance de l’API et l’orientation vers la 3D, il est évident qu’elle est moins facile d’approche que la SDL que j’avais eu l’occasion d’utiliser lorsque j’étais en BTS.

Voici donc ce que j’ai pu obtenir après ces aventures :

test_opengl

Ça reste un début, mais je suis assez contente de moi, je n’ai même pas fini le premier chapitre ! Ce code est issu de l’exemple fournit avec le carré blanc sur fond noir.

Bon week-end à tous :-) .