ez430-Chrono BlueRobin reverse engineering

this is a quick-wrote draft, it will be reviewed

Hello
here is just a little tutorial to give you some idea for reverse engineer and hack your next gadget

today i would like to know how the blueRobin chest strap can communicate with the ez430-chrono

the software delivered with the watch contain a "BlueRobin emulator"

the software only launch when the CC1111 dongle is plugged – ok, no problem

the dongle is seen as /dev/ttyACM0 and is configured at 115200 baud

let’s assume we have 2 dongles CP2102 providing usb serial port /dev/ttyUSB0 and /dev/ttyUSB1

and they are connected together like this

gnd ---- gnd
RX  <--- TX
TX  ---> RX

close the software, unplug the CC1111 dongle.

plug the 2 dongle CP2102 (FTDI dongles  will certainly work too)

create a fake ttyACM0 symbolicaly linked to /dev/ttyUSB0

sudo ln -s /dev/ttyUSB0 /dev/ttyACM0

set the speed of both dongle:

sudo stty -F /dev/ttyUSB0 speed 115200
sudo stty -F /dev/ttyUSB1 speed 115200

in a terminal be ready to read the output of ttyUSB1 = what the software send to ttyACM0

cat /dev/ttyUSB1 | xxd -p

the probleme here is that xxd only write the line to the terminal when it get a full line, so we can use the option "-c 10" or even "-c 1" to reduce the line, but it would be hardly readable.

I prefered send a bunch of zeros from another terminal whit this command:

echo 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 | xxd -p -r  > /dev/ttyUSB0

so this technic help me to cut the communication in several sentence

In Fine, I get this : ( I add some comment while i capture to remind me what the "sentence" means)

mathieu@confusion:~$ cat /dev/ttyUSB1 | xxd -p
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000ff01030aff00
04000aff0004000aff0004000aff0004000aff0004000aff0004000aff00
04000aff0004000aff0004000aff0004000a000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
init ^^^ control center launch
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000ff030798ffff000aff02030aff0504280aff
0a060000000aff0504290aff0a060000000aff05042a0aff0a060000000a
ff05042b0aff0a060000000aff05042c0aff0a060000000aff05042d0aff
06030aff0a060000000a0000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
start, sweep from 40 to 45 bpm, then stop
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
00000000ff030798ffff000aff02030aff05042d0aff0a060a00000aff05
042d0aff0a061401000aff05042d0aff0a061e02000aff05042d0aff0a06
3205000aff05042d0aff0a063c07000aff05042d0aff0a06500a000aff05
042d0aff0a065a0e000aff06030a00000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
start, sweep from 1 to 10 km/h, then stop
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
0000000000000000ff030798ffff000aff02030aff05042d0aff0a06110f
000aff05042d0aff0a062110000aff05042d0aff0a063112000aff05042d
0aff0a065116000aff05042d0aff0a06611a000aff05042d0aff0a06811f
000aff05042d0aff0a069125000aff06030a000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
start, sweep from 1 to 10 mph, the stop
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
TX ID: 1677711
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000ff07030aff31160380000007
d90101061e0000000000000000000aff0004000a00000000000000000000
000000000000000000000000000000000000000000000000000000000000
0000000000000000ff31160381020307d90101061e000000000000000000
0a0000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000ff31160381020307d90706
061e0028000500000000000a000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
ff3116070000000000000000000000000000000000000aff09030a000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
^^^ here i try to set the time : 01:02:03 AM, 4°C, 5m Alt...

Ok, I Hope this little tuto will help you

I think that the more useful command in this tuto is "xxd" : it can translate octet-stream to readable string and make the inverse operation with the "-r" option.

And now a litle script to watch the cpu load of your computer directly on your watch :

#! /bin/sh

stty -F /dev/ttyACM0 speed 115200

# send the initialisation frame
echo "ff0307beffff000aff02030a" | xxd -r -p>  /dev/ttyACM0

sleep 1

while true
do  
    BPMDec=`cat /proc/loadavg | sed 's/\(.\)[.]\(..\).*/\1\2/g'`
    BPMHex=`printf "%02s" $(echo "ibase=10;obase=16;$BPMDec" | bc) | tr ' ' '0'`

    data=ff0504`echo $BPMHex`0aff0a060af3010a

    echo $data | xxd -r -p>  /dev/ttyACM0
    sleep 1

done

# send the termination frame -- never used since there is a "while true" before
echo "ff06030a" | xxd -r -p>  /dev/ttyACM0

exit 0

Authentification SSH par clé privé/clé publique

Authentification SSH par clé privé/clé publique

l’authentification par clé necessite 2 clés :
la clé publique et la clé privé. Ces deux clé sont complémantaires
- la clé publique : ~/.ssh/id_dsa.pub
elle devra etre ajoutee sur le serveur dans le fichier ~/.ssh/authorized_keys2 du user utilisé pour la connexion
sur des vieilles versions de ssh ou des OS moins standard, il est possible qu’il s’agisse de :
~/.ssh/authorized_keys
~/.ssh2/authorized_keys2
- la clé privé : ~/.ssh/id_dsa
elle devra rester sur la machine cliente et être bien protégée (quiconque l’aura pourra s’authentifier sur le serveur)
1 ) si il n’y a pas de clés ou que la clé publique a été retirée, créer de nouvelles clés
attention: vous risquez d’ecraser une clé privé existante et ainsi d’empecher la connexion
a un serveur ayant la clé publique correspondante.
#  ssh-keygen -t dsa -P ""
ici on crée des clés de type dsa , avec un mot de passe vide (si on met un mot de passe, il sera demandé à chaque connexion en plus de l’échange de clé)
( # keygen -h pour connaitre toutes les possibilités )
les fichiers suivants sont créés :
~/.ssh/id_dsa
~/.ssh/id_dsa.pub
2 ) ajouter la clé publique d’un client à un serveur
allers sur le client, dans le répertoire ~/.ssh/ du user à utiliser pour la connexion.
copier la clé publique sur le serveur :
# scp id_dsa.pub <user>@<serveur>:.ssh/
vous connecter sur le serveur :
# ssh <user>@<serveur>
(le mot de passe est demandé)
ajouter la clé publique du client dans les clé authorisées du serveur :
# cat .ssh/id_dsa.pub >> .ssh/authorized_keys2
supprimer ce fichier, maintenant inutile
# rm -f .ssh/id_dsa.pub
très important !  si ce n’est pas fait, regler les droits du fichier authorized_keys2, sinon ssh refuse la connexion.
# chmod 600 .ssh/authorized_keys2
vous déconnecter
# exit
vérification :
reconnectez vous au serveur :
# ssh <user>@<serveur>
(cette fois, le mot de passe n’est plus demandé)
Troubleshouting
un mot de passe est toujours demandé :
- si vous avez utilisé une clé existante, celle si a peut-etre un mot de passe, essayez de le retirer avec "ssh-keygen -p"
- verifiez les droits des fichiers présents dans .ssh
- l’authentification par clé a elle été désactivée ? voir dans /etc/ssh/sshd_config du serveur et dans /etc/ssh/ssh_config du client.
pour plus d’info : ajouter l’option "-v" ou "-vv"
se connecter avec PuTTY ?
le format des clé est différent pour le client Putty. utiliser C:\Program Files\PuTTY\puttygen.exe pour convertir la clé (conversion>import key, puis "save private key")
ensuite dans putty, spécifier la clé sauvegardée dans Connection>SSH>Auth>"Private key file for authentification"
un bon article :

Slitaz base avec wifi, ssh, screen et IRC sur un HP t5530

installation de Linux Slitaz sur un thin client HP t5530

Le but ici est d’avoir une linux-box simple, connectée en wifi sur un réseau WPA2, exécutant un serveur ssh, un "screen" et un client IRC "rhapsody".

le t5530 (idem t5520) est un client léger dispose de 128Mo de RAM, ce qui est assez peu.
nous allons donc partir d’un version "base" de slitaz pour que le système puisse fonctionner.
Je rappel le principe de slitaz :
le média de boot contient 3 choses
- les fichiers de choix de boot : boot/extlinux/*
- le noyau linux : boot/bzImage
- le filesystem qui sera décompressé en ram lors du boot : boot/rootfs.gz
en l’occurrence, cela signifie que le système fonctionnera uniquement avec la ram une fois le système booté et que le média de boot n’est pas monté en temps normal.
De cette façon, une machine sous slitaz supportera très bien d’être arrêté en coupant son alimentation.
De plus cette façon de procéder à l’avantage de prolonger la durée de vie de la Flash, qui n’aime pas beaucoup les écritures répétées.
Cependant, le souci est  que de l’espace en RAM est utilisé pour stocker le filesystem lors du fonctionnement, or nous avons ici très peu de RAM.
nous allons donc utiliser  l’image "base" de Slitaz, qui ne fait que 8 Mo, nous rajouterons ensuite uniquement les paquets necessaires. Sachez tout de même qu’il existe une version  "loram" plus optimisée pour les systèmes ayant peu de mémoire vive.

voici la marche a suivre (sous windows)

choisir slitaz base cooking ici:
ayez une clé usb disponible.
sous windows utilisez le soft tazusb.exe :
ce programme vous permettra de créer une clé usb bootable avec l’image Slitaz téléchargée.
démarrez votre thin client avec la clé USB créée.
à la fin du boot, vous aurez peut-etre un message d’erreur, tapez Ctrl-C pour vous en débarrasser.
loggez vous avec l’identifiant et le mot de passe suivant : root / root
votre client doit avoir accès à Internet par ethernet

installez slitaz sur le disque embarqué :

vérifiez la présence de disque sur la machine :

# fdisk -l
vous devez voir votre clé usb et le disque embarqué.
montez la clé usb
# mount  /dev/sda/ /media/usbdisk/
vous devez disposer de l’iso originale pour installer le sur un disque, nous allons la récupérer
# cd /media/usbdisk
# wget http://mirror.slitaz.org/iso/cooking/flavors/slitaz-cooking-base.iso

formater le disque embarqué pour recevoir slitaz :

# tazusb format /dev/hda1

enfin installer slitaz base sur le disque:

# tazusb gen-iso2usb /media/usbdisk/slitaz-cooking-base.iso /dev/hda1
éteindre, retirer la clé USB, redémarrer.
vous devez avoir le me boot que précédemment.
vous pouvez commencer à installer des paquets

pour le wifi :

installer les modules qui prennent en charge les cartes et dongles wifi:

tazpkg get-install linux-wireless

il y a des chances que les modules disponibles ne soit pas ceux du noyau qui est utilisé en ce moment. c’est pourquoi il faut récuperer le dernier noyau aussi.

tazpkg get-install linux
Il faut placer le noyau au bon endroit avec le bon nom pour pouvoir rebooter la prochaine fois sur le bon noyau
(et le wifi ne fonctionnera pas avant ce reboot, faute de module compatible)
donc montez votre media
mount /dev/hda1 /media/flash

copier le noyau au bon endroit

cp /boot/vmlinuz-2.6.37-slitaz /media/flash/boot/bzImage
installer wpa_supplicant
tazpkg get-install wpa_supplicant

pour le ssh

modifier  /etc/rcS.conf pour que le serveur ssh se lance au démarrage :
# vi /etc/rcS.conf
modifier la ligne RUN_DAEMONS pour avoir ceci :
RUN_DAEMONS="dropbear dbus hald firewall slim"
et dans /etc/daemons modifiez la ligne DROPBEAR_OPTIONS pour avoir :
DROPBEAR_OPTIONS="-b /etc/dropbear/banner"

pour screen

tazpkg get-install elfutils
tazpkg get-install screen

pour le client IRC

tazpkg get-install rhapsody

configuration du réseau

rajout d’un "sleep 5"  au début de /etc/init.d/network.sh pour laisser le temps au noyau de detecter/configurer le materiel avant de monter l’interface réseau
# vi /etc/init.d/network.sh
configuration de /etc/network.conf pour renseigner son SSID et ses identifiant WPA
# vi /etc/network.conf

sauvegarde des modifications

Les modifications faite ne sont faites que dans la RAM, dans l’état actuel des choses un reboot vous ramènera à un système  vierge comme au début de cette page.
pour sauvegarder les modifications, il faut utiliserla commande "tazusb" :
# mount /dev/hda1 /media/flash
# tazusb writefs gzip
# cp /rootfs.gz /media/flash/boot/rootfs.gz
Bon Courage.

Reminder for myself

the next post i plan :
-a gps logger
-a voltage regulator for mountig the t5510 in a car
-some Processing sketchs
-…

cheapest usb-to-serial cable.

T6X USB to TTL serial cable

T6X USB to TTL serial cable

If you play with microcontrollers and embedded systems like SOHO routers, you may need a serial connection to monitor your target and sometime (everytime) realize that it don’t really work as expected.

The lucky of you may have old enough computer to  have a real RS232 serial port with the db9 socket and can use this interface with a TTL target thought the traditional max232.

But for the others, the recent computer have no longer this interface, so the only inteface available is the USB.

With a quick search on the Internet you can find USB to TTL-serial on several microcontroller-related website such as sparkfun, seeedstudio, nkc electronics, Adafruit Industries from approx $14 to $20 or on Ebay as low as $8.50 here.

But my best finding is the USB cable (see image) sold with my chinese RC transmitter (a Turborix 6ch 2.4GHz). It’s given as a "programming cable" without any other information. The truth is that this cable is nothing else than a USB to TTL-serial cable. Its price is as low as $2.99

The dongle is based on the Silabs’ cp2102 chip and provide only TX, RX and GND with the 3 wire cable but I plan to change it  to use a 4 wire cable with the fourth wire soldered on the USB’s VCC (5V). By this simple mod I would be able to USB power some little MCU’s projects.

The drivers  are available on the manufacturer site , for the most of the OS , including Linux, MacOS, Windows CE/2000/XP/Server 2003/Vista/7 (note that it was recognize "out-of-the-box" as ttyUSB0 and works on ubuntu and probably on others linux)

For the mini-DIN plug at the end ot the cable, don’t worry, just replace it with a standard header.

Drawbacks

- the 3 wire cable don’t provide VCC to the target

-only suitable for 5V design (? to be tested) edit :It works great in 3.3V, and the 3.3V built-in regulator can provide 100mA so i manage to power and get data from a EM410 GPS Module without any other component.

for a far similar dongle which provide 3.3V try the Ebay Usbflying’s dongle It’s based on the cp2102 too

for a bit-bang capability you can use a FTDI cable such as this one

for a full-featured USB-to-UART I propose you this device

and If you want even more, try the Hackaday’s Buspirate

Hewlett-Packard t5510 et Linux

Slitaz sur un Hewlett-Packard t5510 sans écran
ou
Linux dans 32Mo sur une carte mini-ITX Fanless

Description du matériel : HP t5510

Processor                            Transmeta Crusoe 800 MHz
Flash                                     32 MB Disk-On-Module (DOM)
Memory                               128 MB DDR SDRAM
(NOTE: 16 MB of system RAM is reserved for processor usage.)
Graphics                              ATI Radeon 7000M with 16 MB discrete video RAM
Operating System            Microsoft® Windows® CE. NET v4.20
Browser                               Microsoft® Internet Explorer 6.0 for Windows CE .NET
PCI                                        1 slot available with optional expansion module sold separately

le t5510 est une "thin client" produit par Hewlett-Packard, c’est à dire un ordinateur de bureau qui est censé ne faire tourner que le minimum nécessaire sur ses propres ressources, toutes les tâches gourmandes étant traitées sur un serveur central.

les "thin clients" n’ont donc généralement pas de disque dur, le stockage des données est aussi réalisé sur le serveur central. En résumé, cette machine ne contient que des outils pour se connecter ou afficher ce qui est traité. Voilà la raison pour laquelle le HP t5510 n’embarque que 32Mo de Mémoire morte (DOM).

A l’Intérieur

Cette machine n’est composée que d’une seule carte au format mini-ITX, (environ 17×17 cm) alimentée sous 12V. Ce qui est aussi très intéressant est qu’elle ne comprend aucune pièce mobile (mémoire morte de type flash et pas de ventilateur) on dit d’une telle machine qu’elle est "solidstate"

Utilisations

J’ai pour projet d’utiliser ce client comme ordinateur de bord sur une automobile pour des application de monitoring. sa tension d’alimentation ainsi que son caractère solidstate en fait une machine bien adaptée à cette tâche.

L’autre utilisation possible est  une utilisation en tant que serveur de lecture de musique et radio en ligne, de partage de fichier, de mail, etc. Il pourra fonctionner 24h/24 dans un petit appartement ou une chambre  et se faire totalement oublier (absence totale de bruit, faible consommation, faible encombrement).

Vous remarquerez que ces application ne nécessitent jamais de moniteur – d’ailleurs, je n’en ai pas, je n’ai que des ordinateurs portables sous la mains.

Le but de ce tutoriel va donc être  d’installer un système d’exploitation pleinement fonctionnel en lieu et place du Windows CE.NET présent sur cette machine.

sources :
idée d’utiliser QEMU :

http://www.pendrivelinux.com/portable-qemu-persistent-ubuntu-linux/

plus d’info QEMU :

http://www.h7.dion.ne.jp/~qemu-win/HowToFloppyCdrom-en.html

slitaz:

http://www.slitaz.org/

Préliminaires : Modifions Slitaz dans une Machine Virtuelle QEMU

pour les modifications de cette distribution, nous allons la démarrer dans une machine virtuelle, sur notre PC

Ingrédients ;-)

- un PC sous windows (fonctionne aussi sous Linux, en adaptant)

- qemu,

- une clé usb et

- l’iso de slitaz "justX"

C’est parti !

Créez un répertoire "Slitaz"

récupérez QKUB.exe et décompressez-le dans le répertoire "Slitaz" :

http://pendrivelinux.com/downloads/QKUB.exe
(edit : il semblerais que le lien ne fonctionne qu’à partir du site pendrivelinux.com ; lorsque vous arrivez sur le site, retapez "/downloads/QKUB.exe à la fin de l’URL et ça fonctionnera ! )

récupérez slitaz justX et placez le dans le répertoire "Slitaz"

http://mirror.slitaz.org/iso/2.0/flavors/slitaz-2.0-justX.iso

Modifiez la dernière ligne de Slitaz\Launchubuntu.bat de la façon suivante

.\qemu\qemu -L .\qemu -kernel-kqemu -std-vga -localtime -soundhw all -m 256 -cdrom slitaz-2.0-justX.iso -hda \\.\PhysicalDrive1 -boot d

explications :

-m 256  ->  256 Mo de Mémoire vive alloué à l’émulateur

-cdrom slitaz-2.0-justX.iso  ->  l’iso du liveCD reconnu comme un cdrom

-hda \\.\PhysicalDrive1  ->  !!à modifier suivant votre config!! le "Disque1" de mon PC (voir dans le gestionnaire de disque Windows) c’est a dire ma clé USB. une erreur de disque pourrait être désastreuse pour votre PC.

-boot d  ->  on boot sur le cdrom dans un premier temps (qui est l’iso de Slitaz)

enregistrez, lancez "Launchubuntu.bat"
(à la première utilisation, ça installe KQemu)

… deux fenêtre s’ouvre, dont une pour l’écran virtuel.

Au splash de slitaz taper "fr" puis <entée>
puis encore <entrée>

… ca charge

à la fenêtre de dialogue "tazx", choisissez votre resolution.

… ça charge nickel jusqu’à la fin

vous voilà avec un bureau Linux dans une fenêtre.

lancez un terminal dans slitaz

passer root :

# su root
<root>

juste pour vérifier que vous avez donné accès au bon disque, vérifier que les valeurs données par la commande suivante ne sont pas aberrantes.

# fdisl -l

formatez la clé usb.

# tazusb format /dev/hda1

entrez un nom pour la clé usb si "TazUSB" ne vous convient pas

# tazusb gen-liveusb /dev/hda1
# exit
# poweroff

Linux s’éteint, Qemu se ferme

Notre clé USB est maintenat prête à booter. on pourrais la brancher sur le t5510,  seulement on a pas d’écran ni de clavier sur le t5510, pour répondre aux questions du démarrage et de plus pour installer slitaz sur un autre disque à partir de cette clé, il faut qu’elle contienne aussi le fichier iso de slitaz.

on va donc rebooter sur la clé usb avec Qemu:

Faite une copie de la LaunchUbuntu.bat renommez la p.ex. "launch_cléUSB.bat"
modifiez-en la dernière ligne de cette façon :

.\qemu\qemu -L .\qemu -kernel-kqemu -std-vga -localtime -soundhw all -m 512 -hda \\.\PhysicalDrive1 -boot c

[ on a retiré la directive cdrom et on demande de booter sur le disque dur (hda) ]

le redémarrage est similaire au lancement précédent de Slitaz, sauf que les données sont initialement lues sur la clé USB.

….vous voilà donc dans une machine virtuelle sous Slitaz-installé-sur-votre-clé-USB.

modification à faire pour utiliser sur un thin client HP t5510 headless (sans ecran/clavier/souris )  avec ce Slitaz:

Activation du serveur ssh

dans un terminal

# su root
# nano /etc/rcS.conf

dans la ligne RUN_DAEMONS= ajouter "dropbear" (sans les guillemets)

Ctrl-X / O / <entée>

pour sauver tout ça

# nano /etc/daemons.conf

dans la ligne DROPBEAR_OPTIONS= , retirer -w et -g pour permettre l’acces ssh à l’utilisateur root

ça y est le ssh devrait être actif au boot de cette façon

Profitons-en pour installer tout les logiciels nécéssaires puisque nous récupèrerons ce filesystem pour le Slitaz définitif.

ajout de logiciels : par exemple "mpg123" pour passer de la musique

#  tazpkg get-install mpg123

faite "y" pour accepter d’installer les dépendances

vous pouvez faire encore quelques "tazpkg" pour installer ce que vous voulez.

Sauvegarde des modifications faites au système :

Vous devez maintenant régénérer l’archive contenant le système de  fichier compressé  "rootfs.gz"

# tazusb writefs gzip

répondre "yes" pour que la configuration de son/vidéo ne soit pas gardé (je rappelle qu’on est encore sur l’émulateur et non sur la machine cible.)

pour le t5510 – qui a une mémoire de 32Mo, faite attention à ce que le fichier  rootfs.gz  généré ne dépasse pas les 30Mo.

Ce fichier est placé automatiquement dans /

montez la clé USB pour pouvoir écrire dessus:

mount /dev/hda1 /media/usbdisk

si vous avez de la place sur votre clé usb :

# mv /media/usbdisk/boot/rootfs.gz /media/usbdisk/boot/previous.gz

pour sauvegarder l’ancien système de fichier compressé.

ensuite on le remplace par celui que l’on vient de compresser.

# mv /rootfs.gz /media/usbdisk/boot/rootfs.gz

Voilà, à ce point, si on redémarre ce système, le serveur ssh sera lancé automatiquement.

Paramètres de boot pour la configuration "headless":

dernier problème : au départ quelques questions sont posées à l’utilisateur, or sans écran, clavier ni souris, celui-ci ne pourra pas s’en rendre compte et y répondre.

nous allons donc modifier le fichier /media/usbdisk/boot/extlinux/extlinux.conf  afin de ne laisser que le nécessaire. Ce fichier est un fichier de type syslinux.conf contenant des directive pour le lancement du noyau Linux.

# nano /media/usbdisk/boot/extlinux/extlinux.conf

On va ne laisser qu’une seule façon de démarrer, et on va définir ici le type d’affichage, le driver de son, la langue et le clavier. De cette façon, ces informations ne serons pas demandées au démarrage.

pour le t5510, les cheatcodes à mettre sont les suivant:

screen=text sound=via82xx lang=fr_FR kmap=fr-latin1

notez que le mode d’écran "text" n’est pas un mode graphique et que par conséquence le serveur X ne sera pas lancé. Vous pouvez remplacer "text" par "1024x768x24" par exemple pour du graphique en 1024 par 768 sous 24 bit

finalement, notre le fichier minimal contiendra  :

default slitaz

label slitaz
kernel /boot/bzImage
append initrd=/boot/rootfs.gz lang=fr_FR kmap=fr-latin1 screen=text sound=via82xx rw root=/dev/null vga=normal autologin

encore que quand il n’y a qu’un "label", default et timeout sont peut etre inutile ; vga=normal et autologin sont peut être inutile aussi à cause de screen=text
(je n’ai pas essayé en les retirant)

sauvez le fichier ( Ctrl-X / O / <entée> )

nous allons aussi mettre dans cette clé USB l’iso de slitaz pour que le systeme puisse s’installer sur un autre disque

(si vous êtes derrière un proxy faite d’abord :

# export http_proxy=http://<adresseproxy>:<portproxy>

en mettant vos propres parametres de proxy)

# cd /media/usbdisk
# wget http://mirror.slitaz.org/iso/2.0/flavors/slitaz-2.0-justX.iso

Je vous conseille maintenant de redémarrer la machine virtuelle pour vérifier que tout se passe bien.

Vérifications du fonctionnement :

rebootez pour essayer :

# reboot

si le système démarre entièrement sans aucune action de votre part , ça devrai fonctionner sur le t5510

se loguer (root/root), éteindre (# poweroff)

retirez la clé USB de votre PC

Les choses serieuses (et amusantes)  : premier boot de notre Slitaz sur le Thin Client

branchez la clé USB  sur votre t5510, allumer.

[(edit) la première fois, il se peut que vous ayez besoin d'entrer dans le bios pour choisir de booter aussi sur un disque USB, malheureusement cette opération va obligatoirement nécessiter un écran et un clavier ( je mettrais en ligne la combinaison de touche à faire pour activer ça quand on a pas d'écran mais juste un clavier) ]

le système devrai être joignable par ssh sur votre réseau dans moins de 2 min

Slitaz embarque un client dhcp. Faites en sorte que votre t5510 obtienne une adresse IP et faite en sorte de savoir quelle est cette adresse. En ce qui me concerne, j’ai seulement branché mon t5510 avec un câble réseau sur ma neuf-box, et dans un menu de celle-ci j’ai regardé quels était les clients dhcp connectés et leurs adresse IP.

A partir d’un ordinateur ayant un client ssh, connectez vous à votre t5510:

# ssh root@192.168.1.3

(dans le cas ou le t5510 a obtenu l’adresse 192.168.1.3)

loguer vous : user : root, mot de passe : root

vous voilà sur votre système embarqué. mission presque accomplie. En effet si le système fonctionne actuellement entièrement sur la mémoire vive, il a utilisé les données de la clé USB pour démarrer. Notre but est qu’il puisse démarrer ainsi en utilisant les données du Disk-On-Module. il faut donc recommencer la manipulation de la même façon. les seules différences seront que la cible de l’installation du système sera le disque hda1 au lieu du disque sda1 et que nous allons utiliser l’image iso stockée sur la clé usb à la place du cdrom pour générer le système.

Pour cela : formater la flash du t5510 (32Mo):

# tazusb format /dev/hda

(en effet maintenant, le Disk-On-Module est reconnu comme /dev/hda et la clé USB comme /dev/sda1 , vous pouvez verifier avec "# fdisk -l" )

monter la clé usb pour pouvoir y lire l’iso de Slitaz:

# mount /dev/sda1 /media/usbdisk/

puis générez le système sur hda1 à partir de l’image iso contenu sur la clé USB

# tazusb gen-iso2usb /media/usbdisk/slitaz-2.0-justX.iso /dev/hda1

à ce stade le système est installé sur le client, mais comme précédemment il faut résoudre les problèmes lié au fait qu’on a ni écran ni clavier ni souris.
Pour les modifications du filesystem et des options de boot, on ne va pas s’embêter, on va recopier simplement les fichiers générés et modifiés plus tôt.

(d’où la nécessité d’avoir un rootfs.gz de moins de ~30 Mo )

# mount /dev/hda1 /media/flash
# cp /media/usbdisk/boot/*    /media/flash/boot/

voilà, vous pouvez maintenant éteindre la machine

# poweroff

et retirer la clé USB


Le Moment de Vérité : un boot autonome

le DOM contient tout le nécessaire et a bien été règle par tazusb pour booter.

appuyer sur le bouton "Marche" et normalement dans moins de 2 min votre machine est joignable sur le réseau !!!


							
Suivre

Recevez les nouvelles publications par mail.