Archive for the 'Computers' Category

DIY: Configuration d’un lecteur de musique réseau

samedi, décembre 8th, 2018

J’ai reçu à mon anniversaire une petite chaîne hifi pour le salon du haut/chambre d’amis, et j’ai voulu lui adjoindre un lecteur réseau pour pouvoir lire notre musique facilement, comme dans la salle de vie en bas.

En bas, j’avais eu la chance de tomber sur un Pioneer N-30 d’occasion, parce qu’à 500€ neuf, pas moyen que je l’achète autrement. Par contre pour haut ça n’a pas été possible car

  • y’en avait pas à un prix acceptable
  • ça aurait été moche comme tout avec ce petit set Sony TA-88/ST-88, non ?
Sony TA-88, ST-88 (et casque Pioneer SE-L40)

Je me suis donc décidé à en monter un moi-même. Pour faire un truc comme ça, la meilleure solution, c’est un Raspberry. Les Raspberry, c’est, en gros, un ordinateur de la taille d’une carte de crédit et de la puissance d’un ordinateur de 2010. Ça fonctionne sous Linux, il y a énormément de ressources sur Internet sur le sujet et, bien que je n’irai pas jusqu’à dire que tout le monde peut s’y mettre, c’est quand même une des portes d’entrées les plus larges pour commencer à adapter du logiciel à ses besoins. 

Les courses

J’ai donc fait une liste de courses (dans laquelle j’avais déjà quelques éléments qui traînaient, mais je mets tout pour celleux qui partent de zéro) :

L’installation

J’ai choisi de tester (puis j’ai adopté) Runeaudio, une distribution Linux Raspberry qui fait exactement ce que je cherche : lecture de fichiers audio à travers un partage réseau, et « récepteur » AirPlay et DLNA. 

J’ai téléchargé la version Runeaudio 0.5 beta 20180903, qui supporte le Pi 3B+. Attention, il y a plusieurs liens de téléchargements. Bien prendre la version pour le Pi 3B+, à savoir 20180903_runeaudio_rpib2.img.gz.

Ce fichier se dézippe, puis on l’écrit tel quel sur la carte microSD à l’aide d’un logiciel spécialisé (dd sous Linux). Raspberry fournit des documentations pour le faire à partir de Linux, Windows ou OS X. Ils le disent clairement mais ça ne fait pas de mal de le répéter : faites très attention au périphérique de destination, ou vous pourriez écraser le mauvais disque.

Il faut ensuite configurer deux choses : l’écran tactile, et le DAC. Pour le DAC, c’est très facile : il n’y a rien à faire.

Pour l’écran tactile, le manuel très fin qui vient avec nous indique de modifier et/ou ajouter quelques lignes au fichier /boot/config.txt, qui se trouve à la racine de la première partition de la carte SD (d’environ 100Mo) :

max_usb_current=1
hdmi_group=2
hdmi_mode=87
hdmi_drive=1
hdmi_cvt=1024 600 60 6 0 0 0

Attention, certaines de ces lignes sont déjà là et doivent être modifiées ou décommentées. Personnellement j’ai aussi ajouté :

display_rotate=3
lcd_rotate=3

Car je voulais mettre l’écran en mode paysage. Ces paramètres pivotent l’écran, mais pas la matrice tactile, pour laquelle il faut modifier le fichier /etc/X11/xinit/xinitrc, qui se trouve dans la deuxième partition de la carte SD (d’environ 4Go), pour y ajouter la ligne :

xinput --set-prop "WaveShare WS170120" "Coordinate Transformation Matrix" 0 -1 1 1 0 0 0 0 1

Il reste à pré-configurer le Wifi, pour ne pas avoir à brancher de câble réseau. Cela se fait dans le fichier /etc/netctl/wlan0 (à créer, sans extension) :

Description='wlan0 connection'
Interface=wlan0
Connection=wireless
Security=wpa-configsection
IP=dhcp
WPAConfigSection=(
'ssid="
VOTRE_POINT_DACCES"'
'psk="
VOTRE_CLE_WPA"'
'key_mgmt=WPA-PSK'
'proto=WPA'
'group=TKIP'
'pairwise=TKIP'
'priority=3'
)

On peut maintenant assembler les différents éléments et démarrer le Pi !

Connexions et démarrage

La première étape sera de souder les broches du DAC, ainsi que ses prises RCA, et de souder le jack d’alimentation sur l’entrée du convertisseur 12-5V (ne pas confondre le plus et le moins surtout, utilisez un multimètre si nécessaire). J’ai utilisé des câbles pour pouvoir les faire sortir où je le voudrai sur le châssis.

Le jack d’alimentation
Les soudures du DAC

Ensuite, on branche le DAC sur le port d’extension du Raspberry.

Installation du DAC

On branche un câble USB – Micro USB du convertisseur vers l’entrée du Pi.

Câble d’alimentation

On branche le côté data (fil épais) du doubleur de puissance USB sur un port du Pi, puis le côté « power only » sur une autre sortie du convertisseur (ceci est nécessaire car l’écran consomme plus que ne peut fournir le Pi sur un port USB).

Doubleur de puissance USB

On branche un câble USB – Micro USB du doubleur vers l’entrée USB de l’écran.

Câble USB vers l’écran
Câble HDMI vers l’écran

On branche le câble HDMI.

On met la carte SD, et on branche l’alimentation. L’écran n’est pas utilisé par défaut sur Runeaudio; il faut donc, une fois le Pi démarré, se connecter par un navigateur à http://runeaudio.local/ (ou http://runeaudio.lan/ ou http://runeaudio/, cela dépend des box internet. Au pire, il faudra aller récupérer son IP sur la box, puis s’y connecter directement.

De là, on peut aller activer l’écran LCD par le Menu, puis Settings : Local browser :

Choix du local browser

On peut aussi en profiter pour activer le DAC (choisir HifiBerry DAC dans la liste dans Settings, puis redémarrer le Pi) :

Choix du module noyau hifiberry-dac

Il faut aussi régler la sortie de MPD sur le DAC après redémarrage :

Réglage de MPD

Et voilà, la partie informatique/logicielle est prête. Il reste à mettre tout cela dans une belle boîte, ce qui fera l’objet d’un deuxième article.

Ansible: Ajouter plusieurs utilisateurs avec plusieurs clés publiques

mercredi, mai 30th, 2018

Vu que ça m’a pris un peu plus longtemps que je n’aurais voulu à trouver une syntaxe à peu près propre pour ajouter avec Ansible plusieurs utilisateurs sur un serveur, avec chacun plusieurs clés publiques SSH, voici comment j’ai fait:

dans login-vars.yml

users:
- login: "user1"
  pass_hash: "$6$G1Q........"
  pubkeys: 
    - "ssh-rsa AAAAB3N.....yBd1 user1@first-key"
    - "ssh-rsa AAAAB3N.....eWDp user1@second-key"
- login: "user2"
  pass_hash: "$6$G1A........"
  pubkeys: 
    - "ssh-rsa AAAAB3N.....yCDd1 user2@first-key"
    - "ssh-rsa AAAAB3N.....eaop user2@second-key"

dans roles/setup-users/main.yml

- name: configure user accounts
  user:
    name={{ item.login }} 
    append=yes
    password={{ item.pass_hash }}
  become: yes
  with_items:
    - "{{ shell_users }}"

- name: Add users public keys
  authorized_key:
    user={{ item.login }}
    key="{% for key in item.pubkeys %}{{ key ~ "\n" }}{% endfor %}"
  become: yes
  with_items:
    - "{{ shell_users }}"

Stravomatic : une app Android pour démarrer Strava automatiquement

dimanche, décembre 17th, 2017

Ce week-end, je me suis souvenu que quand j’ai eu mon nouveau téléphone, il comptait mes pas tout seul, et j’ai cherché pourquoi. Il se trouve qu’il y a un service Google Play qui permet aux développeurs de récupérer l’activité de l’utilisateur (marche, course, vélo, etc), et j’ai décidé d’essayer de développer ma première app Android : Stravomatic.

J’utilise Strava depuis quelques années et je le trouve extrêmement utile pour suivre mon kilométrage, mais parfois j’oublie de le lancer chaque matin et chaque soir quand je vais travailler.

Le développement s’est passé bien mieux que je ne pensais au départ, et je crois que j’ai une bonne petite app fiable, qui démarre une activité Strava automatiquement quand je commence à faire du vélo (ou à courir) (ça n’arrive jamais) (sauf ce week-end où j’ai fait plein de tours dans le jardin pour tester, au grand amusement de ma copine et mes voisins). C’est une app simple avec une page de réglages et un composant en arrière plan qui suit ce qu’il se passe :

Comme elle n’utilise pas le GPS, et tire avantage des Google Play Services, elle n’a pas l’air de tirer de manière notable sur la batterie, ce qui me fait bien plaisir.

Je l’ai publiée sur Google Play : Stravomatic, et j’en suis plutôt fier ! J’espère qu’elle servira à d’autres étourdis :)

Mon petit BB-8 fait maison

lundi, février 8th, 2016

Après avoir vu le dernier Star Wars, comme de nombreux geeks, j’ai été épaté par le petit droïde BB-8, et comme de nombreux geeks, j’ai eu très envie d’essayer d’en faire un.

J’ai commencé par dégoter une sphère en plastique de 300mm, et une de 180mm (qui ressemblait plus, d’après mon pied à coulisse, à une sphère de 160mm quand je l’ai reçu…) ; une paire de moteurs. Puis j’ai sorti la boîte à électronique du placard, avec en projet : me lancer et résoudre les problèmes comme ils viennent, plutôt que de  commencer par planifier plein de trucs et de perdre courage au milieu.

DSC_0526

Le début était plutôt facile : enlever les parties inutiles des boules, puis les poncer pour que la peinture tienne (et qu’elles soient bien lisses).

DSC_0534

Ensuite quelques petits calculs pour savoir où placer le châssis le plus bas possible, une petite découpe de contre-plaqué, et j’ai commencé par fixer les moteurs.

DSC_0541

J’ai ensuite ajouté la batterie, le plus bas possible pour essayer de stabiliser le tout le mieux possible :

DSC_0544

Spoiler alert : Cette batterie USB, bien que capable de sortir 2.4A en 5V, n’a pas la pêche nécessaire pour faire bouger quoi que ce soit. Elle s’est vue remplacée par une batterie LiPo 2S que j’utilisais pour mes voitures radiocommandées.

DSC_0550

Puis j’ai commencé la partie facile (pour moi) : un peu de programmation Arduino. J’ai utilisé un récepteur 2.4GHz standard, et ajouté un gyroscope électronique 3 axes, imaginant pouvoir l’utiliser pour compenser un peu le tangage. Enfin, j’ai utilisé un shield moteurs Adafruit pour les moteurs.

DSC_0558

Le résultat.. Spoiler alert : le gyro ne sert à rien, car les moteurs à courant continu et réducteurs sont bien trop imprécis pour compenser quoi que ce soit. Même s’ils l’étaient, ils pourraient compenser le tangage (d’avant en arrière) mais pas le roulis (latéral).

Enfin si, le gyro sert à couper les moteurs et faire marche arrière quand on va droit dans un mur (sinon, le châssis commence à grimper dans la boule et la tête finit par tomber en arrière.)

DSC_0563

Après l’upgrade de batterie, le premier test était plutôt encourageant :

Et voilà les difficultés qui commencent, avec l’ajout du mât :

DSC_0562

Et de la tête, dotée d’aimants pour la maintenir en place (avec ceux du mât en dessous), et des billes multi-directionnelles pour rouler librement sur le corps.

12552541_10205407629492323_2296425100086899696_n

Spoiler alert :les toutes petites billes multidirectionnelles sont bourrées de frottements et roulent très mal. D’autre part, trop d’approximation dans le placement des aimants les faisaient frotter contre le corps, occasionnant de disgracieux grincements (et de disgracieuses chutes de tête).

Mais bon, c’était prometteur. Donc je me suis lancé dans la peinture.

DSC_0565

DSC_0569

DSC_0570

DSC_0571

Après plusieurs heures de masquage, peinture, démasquage, jurons, remasquage, repeinture, etc, je suis arrivé à un résultat imparfait mais pas trop honteux.

DSC_0573

J’ai donc continué avec la tête… (Ici, les « yeux »)

DSC_0574

DSC_0576

Mais à mon grand désespoir, le simple poids des deux yeux (pourtant fabriqués en véritables boules de Noël) entrainait inexorablement la tête vers le sol. J’ai fini par me décider qu’elle était irrécupérable, et je l’ai toute refaite, cette fois ci avec une boule en polystyrène (de la bonne taille cette fois !), et pendant que j’y étais, j’ai refait tout le mécanisme avec de meilleurs aimants, de meilleures billes multidirectionnelles (trois fois plus grosses et sur roulements), et surtout, de meilleures mesures.

DSC_0578

DSC_0589

Et le résultat rend plutôt bien, si vous voulez mon avis !

DSC_0593

Ça roule aussi beaucoup mieux, même s’il y a encore quelques vibrations parasites et qu’il puisse semble que BB-8 a bu un coup ou deux de trop :

Ça m’a pris trois semaines d’arriver à ce point de la construction. Je n’en avais pas encore tout à fait marre, donc j’ai amélioré deux-trois trucs. Principalement, je n’avais pas envie de devoir ouvrir BB-8 à chaque fois que je voulais l’allumer. J’ai donc bricolé un interrupteur magnétique (avec un aimant et un trombone. N’essayez pas avec un vieux capteur de compteur de vélo, ça ne supporte pas l’ampérage, et ça s’auto-soude au premier essai. Ne me demandez pas comment je le sais.)

Évidemment, pour repérer l’interrupteur magnétique de l’extérieur et en approcher les aimants, ce n’est pas évident, mais bon, ça marche quand même car je connais à peu près la hauteur du châssis et je l’ai positionné à peu près à l’ « avant » (qui se repère par l’oeil de BB-8).

DSC_0591

J’ai aussi ajouté une paire de relais, qui sont utilisés pour que l’Arduino puisse s’auto-éteindre au bout de deux minutes sans signal de la télécommande. Cela me permet de ne pas avoir à l’ouvrir pour l’éteindre non plus.

DSC_0590

Et enfin, j’ai collé un mini testeur de batterie LiPo, pour qu’il puisse bipper quand la batterie commence à se vider dangereusement (je dis dangereusement, parce que les LiPo c’est susceptible, ça peut prendre feu si on les regarde de travers).

Voilà, je considère mon petit BB-8 terminé, même s’il est loin d’être parfait ! Je crois que ce n’était pas le plus simple des robots pour un premier, mais bon, je me suis bien amusé à le construire. Peut-être que la prochaine fois je ferai un R2D2, qui, bien que plus demandeur au niveau carrosserie, sera « les doigts dans le nez » niveau mécanique.

Après la construction, je suis allé voir sur Youtube des vidéos d’autres constructeurs de BB-8, et c’est plutôt amusant de voir combien de solutions il y a pour faire rouler une boule sur elle-même. Il y en a de très simples avec une voiture télécommandée dans la boule, d’autres roulent par transmission direct et tournent via une roue inertielle ; d’autres encore sont des robots holonomes équipés de roues multi-directionnelles (très amusant à voir rouler), certains utilisent une transmission indirecte comme le mien, mais une roue inertielle pour tourner (Ce type est bon, mais il a aussi accès à pléthore de matériel, et j’aime à croire que je pourrais faire bien mieux si j’avais des imprimantes 3D, des usineuses CNC, tout le tintouin ET QU’ON ME PAYAIT POUR ÇA), et enfin le modèle de cet ado de 17 ans fonctionne exactement comme le mien, mais bordel ce môme est doué.

Self-shutting-down Arduino

samedi, février 6th, 2016

I have recently finished building my own BB-8 robot (more on that later!) and faced the problem of not wanting to open its body to power it on and off. I came up with the following idea.

self-shutting-down-arduino_schem

Here, the battery is connected to the Arduino’s ground and a simple relay’s ground. The positive lead of the battery is connected to the NO (normally open) pin of the relay, and the Arduino’s VIN pin is connected to the MAIN pin of the relay. So, as long as the relay’s open, no current goes to the Arduino. To start the Arduino, I’ve also connected a push button to the NO and MAIN pins of the relay. When I push the button (in BB-8’s case, it’s a magnetic button), this lets the Arduino boot up.

The only thing needed then, in order to be able to release the button and have the Arduino stay powered, is to close the relay programmaticaly :

 

#define POWER_PIN 2
void setup() {
  pinMode(POWER_PIN, OUTPUT);
  digitalWrite(POWER_PIN, LOW);
}

Then you only need to keep the button pressed during the Arduino’s bootup, and as soon as you hear the relay click, you can release it.

Now, to power off the Arduino, it’s just a matter of setting the relevant pin HIGH on a predefined condition (in BB-8’s case, it’s after 60 seconds of RC signal loss):

void loop() {
  /* do your normal stuff */

  if (now() - rc_signal_lost > 60) {
    power_off();
}

void power_off() {
  digitalWrite(POWER_PIN, HIGH);
}

In my case, the circuit is more complicated, because I’m using a 2S LiPo battery. These things hate being over-discharged, so I added a LiPo battery tester which beeps when the cells’ voltage drop below a certain level. The tester is plugged on the three charge balancing leads of the LiPo battery, which allow to test each cell independantly. So, in my bot I have wired two relays, one of them for each cell’s positive lead. This allows to have the LiPo battery tester without having it draining the power when the bot is off.

Here is the schematics for my bot:

self-shutting-down-arduino_schem

news for few, stuff no-one cares about