Transférer des fichiers entre un ordinateur sous Linux et un smartphone sous Android

Ayant fait l’acquisition d’un smartphone sous Android 8 il y a de ça quelques jours, l’une des premières choses que j’ai essayée de faire c’est d’uploader/téléverser de la musique sur mon appareil.

Il faut préciser que mon ordi tourne sous Linux Debian 10. J’ai un dual boot Windows avec licence, mais je l’utilise très peu, sauf pour les jeux.

J’ai donc utilisé mon moteur de recherche préféré (on se demande lequel quand on achète un android!) et cherché comment mettre de la musique sur le smartphone. Ayant eu un smartphone de la même marque il y a de ça une dizaine d’années, j’ai cru que j’allais brancher mon câble USB et voir apparaître le dossier où mettre ma musique! Bye bye iTune! O que non, ça n’est plus aussi simple!!!!

Je n’ai pas forcément essayé de comprendre le pourquoi du comment, mais j’ai trouvé une solution qui me convient. Certes, elle a l’inconvénient de demander des connaissances réelles en informatique et en particulier des commandes Unix. ça n’est pas un problème pour moi et j’espère pour vous aussi!!!

Bon, j’avais commencé par utiliser AirDroid, qui est possède une jolie interface web permettant de communiquer entre le smartphone et mon ordi via une interface web https://web.airdroid.com/

Grosse, grosse déception : impossible de téléverser/uploader des fichiers de plus de 30 Mo et une limitation du nombre total de Mo uploadés, vraiment basse. La solution c’est une version premium payante.

Alors je suis allé me promener, il faisait beau, je suis allé acheter des piles pour ma télécommande de télé. Bref, j’ai réfléchi et je me suis dit : NO WAY!

Comme indiqué là https://vxlabs.com/2014/11/06/use-adb-to-bypass-dog-slow-mtp-transfer-of-files-from-android-to-linux/ il existe une alternative pour qui connaît un peu les commandes shell sous Linux. L’interface s’appelle ADB (Android Debug Bridge) https://developer.android.com/studio/command-line/adb

Cela suppose donc des connaissances des lignes de commande et a priori de travailler sous Linux! En fait tout ce dont on a besoin est le Android SDK Platform-Tools package https://developer.android.com/studio/releases/platform-tools … qui est disponible sous Linux, Windows et Mac.

Il semblerait donc que ce soit jouable sous Windows aussi (Mac est orienté Unix, donc rien d’étonnant là). Il restera à apprendre quelques lignes de commandes, qui sont accessibles à un utilisateur de niveau « moyen-supérieur ». Si vous voulez un truc avec une interface graphique et tout, passez votre chemin…

Je ferai peut-être un post sur la mise en place et l’utilisation de ADB sous Windows, vu que j’ai le dual boot.

Bon ADB : bien je suis trop content : ça marche! Je vais détailler la marche à suivre

Tout d’abord, vous trouverez tout ce dont vous avez besoin dans les pages suivantes https://developer.android.com/studio/command-line/adb, https://developer.android.com/studio/releases/platform-tools

Pour commencer, vous devez télécharger le Android SDK Platform-Tools, il suffit de cliquer sur le lien dans la page https://developer.android.com/studio/releases/platform-tools « Download SDK Platform-Tools for Linux » (si vous êtes sous Linux naturellement). Enregistrer le fichier, créer un répertoire, dé-zippez le ensuite dans un terminal (gnome-terminal pour moi):

cd
mv ~/Downloads/platform-tools_r30.0.5-linux.zip .
unzip platform-tools_r30.0.5-linux.zip
cd platform-tools/

Dans le répertoire platform-tools, vous avez un certain nombre d’exécutables dont adb, qui est celui qui nous intéresse ici.

Alors vous pouvez télécharger le SDK complet https://developer.android.com/studio/intro/update#sdk-manager, si vous avez en tête de faire du dev pour Android, mais je ne l’ai pas fait parce que ça bouffe des Go et surtout dans le but d’y aller doucement.

Tout d’abord, il faut activer le mode développeur sur votre smartphone. Ce qui est indiqué, c’est :

On Android 4.2 and higher, the Developer options screen is hidden by default. To make it visible, go to Settings > About phone and tap Build number seven times.

Sur Android 4.2 et supérieur, l’écran des options du développeur est caché par défaut. Pour le rendre visible, allez dans Paramètres > À propos du téléphone et appuyez sept fois sur Numéro de build.

Perso, comme je n’avais pas traduit le texte, j’ai cru qu’il fallait taper sept fois le « numéro de build » qui faisait déjà une vingtaine de caractères, argh! Et où? That was the question!

Bon, je suis allé dans Paramètres > A propos du téléphone > Informations sur le Logiciel. Là j’ai « tapé » sept fois sur « Numéro de version » et j’ai rentré mon mot de passe (celui pour déverrouiller le téléphone). Et miracle, ça marche! Dans « Paramètres » apparaît un onglet « Options de développement ». Je clique dessus, je l’active si besoin et j’active « Débogage USB » si ce n’est pas déjà le cas.

Bon je suis très fort, mais c’est avec mon moteur de recherche préféré, toujours lui, que j’ai trouvé la solution détaillée ici : https://www.samsung.com/uk/support/mobile-devices/how-do-i-turn-on-the-developer-options-menu-on-my-samsung-galaxy-device/ en Anglais, mais avec de belles illustrations.

OK, maintenant vous savez que j’ai un Samsung Galaxy (d’occaz). Il doit y avoir moyen trouver la procédure équivalente pour activer les options de développement sur n’importe quel smartphone sous Android.

Ensuite, j’ai connecté mon Samsung à mon ordi via un cable USB. J’ai dû accepter un certain nombre de trucs, peut-être retaper mon mot de passe (je ne sais plus exactement) :

When you connect a device running Android 4.2.2 or higher, the system shows a dialog asking whether to accept an RSA key that allows debugging through this computer. This security mechanism protects user devices because it ensures that USB debugging and other adb commands cannot be executed unless you’re able to unlock the device and acknowledge the dialog.

Lorsque vous connectez un appareil fonctionnant sous Android 4.2.2 ou supérieur, le système affiche une boîte de dialogue vous demandant si vous acceptez une clé RSA qui permet le débogage via cet ordinateur. Ce mécanisme de sécurité protège les appareils des utilisateurs car il garantit que le débogage USB et les autres commandes adb ne peuvent être exécutés que si vous êtes en mesure de déverrouiller l’appareil et d’accuser réception de la boîte de dialogue.

Pour info, une clef RSA est une clef pour système de cryptage asymétrique qui permet à un ordi de se connecter à un autre ordi en toute sécurité. Il y a une clef publique et une clef privée. Je l’utilise pour me connecter en « ssh » sur des serveurs sans avoir à taper à chaque fois mon mot de passe. Pour plus d’information, vous pouvez chercher « chiffrement RSA » sur votre moteur de recherche … préféré.

Bon maintenant, on va connecter le smartphone à votre ordinateur via la Wifi (cool!)

Là je reprends presque exactement ce qui est indiqué dans https://developer.android.com/studio/command-line/adb, à la section « Connect to a device over Wi-Fi (Android 10 and lower) », comme indiqué, pour un Android 10 ou inférieur. J’ai un smartphone sous Android 8, donc c’est bien pour moi. Sinon il faut se référer à la section « Connect to a device over Wi-Fi (Android 11+) », que je n’ai pas lue pour être honnête.

1. Le cable usb branché, je tape

./adb tcpip 5555

puis je peux déconnecter mon cable USB

2. Il faut trouver l’adresse ip de votre smartphone, qui commence par 192.168 (adresse sur le réseau local). Comme indiqué dans le document su-cité, Paramètres > Connexions > Wi-Fi, puis sélectionner « Réseau Actuel » et l’adresse ip locale apparaît, 192.168.1.24 pour moi par exemple. (puis taper sur « annuler » pour revenir en arrière).

./adb connect 192.168.xxx.xxx (remplacer par votre adresse ip naturellement)
./adb device

List of devices attached
192.168.xxx.xxx:5555 device

3. Ensuite, on peut commencer à jouer!

# pour voir ce qu'il y a sur la carte SD
./adb shell ls /sdcard
# pour voir ce qu'il y a dans le répertoire Music du la carte SD
./adb shell ls /sdcard/Music
# pour initier un shell
./adb shell
$ ls
$ ls sdcard
$ ls storage/0E64-F84B/DCIM/Camera/  # le nom du répertoire dans storage "0E64-F84B" est certainement différent chez vous, "DCIM" contient les photos
$ exit

Pour copier les photos depuis le smartphone dans le répertoire /home/benaroya/Images/samsung/Camera (remplacer benaroya par votre nom d’utilisateur!!!), on utilise la commande pull

./adb pull storage/0E64-F84B/DCIM/Camera/ /home/benaroya/Images/samsung

Pour copier un fichier audio depuis votre ordinateur vers le smartphone, utiliser la commande push

./adb push Brooke_Annibale_song_1.mp3 /sdcard/Music

Si vous aimez la Pop/Folk, je vous conseille Brooke Annibale, c’est de la balle. Je l’ai découverte sur Audiotree Live que je vous recommande aussi.

Enfin, pour fermer la connexion (important)

./adb devices -l
./adb -s mydevice disconnect

remplacer mydevice par le code qui apparaît après « device: »
sinon pour déconnecter tous les appareils d’un coup, taper ./adb disconnect tout simplement.

Nous avons vu comment télécharger vos photos sur votre ordi local et comment téléverser votre musique sur votre smartphone via la Wi-Fi. Il ne reste plus qu’à jouer la musique, avec Poweramp par exemple (il faut re-scanner toute la musique dans ce cas).

Le seul défaut de la procédure, c’est qu’il faut brancher le smartphone à votre ordinateur via un câble USB pour initier la connexion TCP. Mais je trouve ça super chouette de téléverser de la musique via la WiFi de cette manière.

Et voilà!!!

Remarque a posteriori : on peut aisément mettre le répertoire contenant l’exécutable « adb » dans le PATH, de manière à ne pas avoir à se placer dans le répertoire en question puis taper ./adb à chaque manip.

Les entrées analogiques de la Beaglebone Black, ARM et PRUs

L’objectif ici est de compiler et d’exécuter un programme permettant de lire une tension sur des pins analogiques. Deux programmes, en fait, l’un côté PRU (Programmable Real-time Unit) et l’autre côte CPU ARM. Finalement, j’ai opté pour les exemples fournis par Texas Instruments, qui est le constructeur du « cœur » (SoC AM3358/9) de la BBB. Au départ, je ne saisissais pas bien comment lancer les programmes fournis par TI, ni l’intérêt exact du SDK. J’ai en plus installé leur « Code Composer Studio » sur ma bécane (CCS), qui prend moultes Giga et est bien complexe. Je vais probablement le désinstaller.
Grâce au projet BeagleScope, dont je parle dans mon précédant post,  en étudiant le fichier deplay.sh, j’ai compris comment lancer un programme (dans le firmware) sur l’un des deux micro-contrôleurs (les fameux PRUs).

Le premier exemple, dans le post précédent, consistait à faire clignoter une LED à partir d’un pin numérique configuré en « output ». Maintenant, nous allons construire et exécuter un projet, nommé « PRU_ADC_onChip » qui  a pour objectif de lire des valeurs sur des pins analogiques (ADC = Analog to Digital Converter) et de les convertir en Volts en fonction d’une tension de référence. Les ADC de la BBB ont 12 bits de résolution et prennent donc des valeurs entre 0 et 4096-1 (4096 = 2 puissance 12). La tension de référence pour les convertisseurs est de 1.8 V, au lieu des 3.3 V pour pour les pins numériques. ATTENTION, ne pas mettre une tension supérieure à 1.8 V au risque d’endommager laBeagleBone! La tension de référence est fournie sur le pin P9_32 (VDD_ADC) et une terre analogique sur le pin P9_34 (GROUNDA_ADC). Vraiment, faite attention de ne pas mettre une tension supérieure à 1.8 V dans les entrées analogiques, please!!!
Les pins d’entrée analogique, sur le header P9, sont numérotées de AIN0 à AIN6 (7 entrées), pins 33 et 35 à 40, le pin 34 étant la terre et le pin 32 étant la référence à 1.8 V.  Les entrées analogiques sont surlignées en vert dans la figure ci-dessous:

Une vidéo illustrant le « projet », dans ses grandes lignes, est disponible ici : How to Use the PRU to Control a Peripheral: PRU_ADC_onChip on Sitara 335x using Beaglebone Black. C’est une bonne idée de la regarder cette vidéo, elle ne dure que 10 minutes (si l’Anglais ne vous rebute pas).

Les explications dans ce post sont certainement transposables à d’autres BeagleBones (Green, Blue), moyennant quelques adaptations.
Note: la résolution est ici de 12 bits, contre 10 bits pour l’Arduino Uno. La résolution standard d’un fichier audio est de 16 bits (signé).
Du coup, cela signifie que le pas de quantification est de 1.8 V divisé par (2 puissance 12, moins 1), soit 0.440 mV environ!

Résumé avec la vidéo TI (traduction) :

Dans certaines situations, il est plus logique de contrôler un périphérique avec un processeur déterministe dédié plutôt qu’avec un cœur ARM à usage général dans un processeur TI. Les applications vont d’un système de surveillance dédié où la charge de traitement peut être déchargée de l’ARM à un environnement en temps réel où le stimulus nécessite une réponse du processeur dans un laps de temps connu. Cette vidéo fournit un exemple d’utilisation du noyau d’unité programmable en temps réel (PRU) pour contrôler un périphérique sur n’importe quel processeur TI avec un PRU-ICSS ou PRU_ICSSG. Dans ce cas, pour contrôler le convertisseur analogique-numérique (ADC) sur le processeur Sitara AM335x à l’aide du BeagleBone Black.

Sur le projet PRU_ADC_onChip :

Il s’agit d’un projet de référence pour l’utilisation du PRU-ICSS pour contrôler un périphérique ADC sur l’AM335x. Le but de ce projet est de fournir un modèle pour contrôler un périphérique sur puce à l’aide du PRU. Il démontre également une application de RPMsg pour la communication ARM-PRU.

Nous allons passer aux choses sérieuses, à savoir la compilation des deux codes, l’un sur la BBB pour le PRU et l’autre sur votre PC sous Linux pour le processeur ARM de la BBB.

La première étape consiste à modifier le fichier /boot/uEnv.txt, puis rebooter.
Dans ce fichier de configuration, il faut dé-commenter la ligne suivante :
disable_uboot_overlay_adc=1, afin d’empêcher le processeur ARM d’accéder à la conversion analogique numérique ADC, car ce sera la tâche du micro-contrôleur.
Re-booter :
sudo reboot now

La seconde étape: le projet fait partie du pru-software-support-package fourni par Texas Instruments (TI) et téléchargeable ici pru-software-support-package. Il est souhaitable de le télécharger sur votre PC, puis de le copier sur votre BBB :
scp pru-software-support-package-5.6.0.zip debian@beaglebone.home:/home/debian/
Sur les deux ordinateurs (PC et BBB), le décompresser :
unzip pru-software-support-package-5.6.0.zip
Le projet s’appelle PRU_ADC_onChip et se trouve dans le répertoire :  pru-software-support-package-5.6.0/examples/am335x/PRU_ADC_onChip.

La troisième étape (1/2) : installation du SDK sur le PC pour la compilation croisée.
On trouve le SDK de TI depuis PROCESSOR-SDK-AM335X, c’est un très gros fichier  « ti-processor-sdk-linux-am335x-evm-06.03.00.106-Linux-x86-Install.bin » (9.2 Go après installation, sur mon PC) . Une fois téléchargé, il faut l’exécuter pour installer le SDK :
chmod u+x ti-processor-sdk-linux-am335x-evm-06.03.00.106-Linux-x86-Install.bin
./ti-processor-sdk-linux-am335x-evm-06.03.00.106-Linux-x86-Install.bin


La troisième étape (2/2) : la compilation croisée (cross-compilation)
Il s’agit de compiler le programme depuis le PC (processeur x86) pour le processeur ARM de la BeagleBone, sur lequel il sera exécuté.
Le code source est dans le fichier pru_adc_userspace.c, qui se trouve dans le sous répertoire PRU_ADC_onChip/pru_adc_userspace
Attention, celui-ci doit être compilé sur votre PC.
Ce n’est pas indiqué explicitement dans le README.txt, mais c’est nécessaire.
Faire l’export suivant pour le dossier bin du SDK :
export ARM_CCT=/home/benaroya/ti-processor-sdk-linux-am335x-evm-06.01.00.08/linux-devkit/sysroots/x86_64-arago-linux/usr/bin
en remplaçant « /home/benaroya » par votre répertoire racine contenant le SDK
Dans le répertoire PRU_ADC_onChip/pru_adc_userspace, on compile :
make clean
make

Enfin, il ne reste plus qu’à recopier le dossier généré « gen » vers l’exemple sur la BeagleBone
scp -r gen debian@beaglebone.home:/home/debian/pru-software-support-package-5.6.0/examples/am335x/PRU_ADC_onChip/pru_adc_userspace/

La quatrième étape : compilation pour le PRU 0 sur la BBB.
dans PRU_ADC_onChip, compiler pru_adc_firmware.c dans la beaglebone :
export PRU_CGT=/usr/share/ti/cgt-pru
make clean
make

Vous pouvez insérer l’export dans ~/.bashrc, pour ne plus le faire à chaque connexion à la BBB.

La cinquième étape : démarrer le PRU.
Comme indiqué dans le post précédent, il faut mettre le code pour le PRU 0 dans le firmware et lancer le remoteproc0. Il y a une erreur dans le programme fourni par TI parce que  pru_adc_userspace.c essayez de lancer automatiquement PRU 1, alors que le programme « pru_adc_firmware.c » est compilé avec des options pour le PRU 0. ça n’a pas fonctionné en l’état chez moi.

Dans pru_adc_firmware.c :
/*
* The PRU-ICSS system events used for RPMsg are defined in the Linux devicetree
* PRU0 uses system event 16 (To ARM) and 17 (From ARM)
* PRU1 uses system event 18 (To ARM) and 19 (From ARM)
*/
#define TO_ARM_HOST 16
#define FROM_ARM_HOST 17

Dans pru_adc_userspace.c :
char firmware[] = "/sys/class/remoteproc/remoteproc1/firmware";
char pruState[] = "/sys/class/remoteproc/remoteproc1/state";

Remplacer remoteproc1 par remoteproc0 ne suffit pas bizarrement.

On revient à nos moutons: renommer et copier le code compilé dans le firmware,
cp PRU_ADC_onChip.out PRU_ADC_onChip-fw
sudo cp PRU_ADC_onChip-fw /lib/firmware/

et démarrer le programme sur le PRU 0
echo 'stop' > /sys/class/remoteproc/remoteproc0/state 2>/dev/null
echo "PRU_ADC_onChip-fw" > /sys/class/remoteproc/remoteproc0/firmware
echo 'start' > /sys/class/remoteproc/remoteproc0/state

Dernière étape : tester
./gen/pru_adc_userspace -c 5
Reading voltage at ADC Channel: 5
Voltage on ADC Channel 5 is 1.7960V
./gen/pru_adc_userspace -c 6
Reading voltage at ADC Channel: 6
Voltage on ADC Channel 6 is 0.9270V
./gen/pru_adc_userspace -c 7
Reading voltage at ADC Channel: 7
Voltage on ADC Channel 7 is 0.0501V

C’est magnifique, car physiquement, le pin AIN4 (canal 5) est rélié à l’analog VDD (1.8 V), le pin AIN5 (canal 6) est « au milieu » (pont résistif de 2k Ohms) et le pin AIN6 (canal 7) est à la masse. Cependant, c’est un peu fluctuant au cours du temps. Apparemment, il y a moyen de moyenner la mesure:
/*
* set the ADC_TSC STEPCONFIG1 register for channel 5
* Mode = 0; SW enabled, one-shot
* Averaging = 0x3; 8 sample average
* SEL_INP_SWC_3_0 = 0x4 = Channel 5
* SEL_INM_SWC_3_0 = 1xxx = VREFN (reduces noise in single ended mode)
* use FIFO0
*/
ADC_TSC.STEPCONFIG1_bit.MODE = 0;
ADC_TSC.STEPCONFIG1_bit.AVERAGING = 3;
ADC_TSC.STEPCONFIG1_bit.SEL_INP_SWC_3_0 = 4;
ADC_TSC.STEPCONFIG1_bit.SEL_INM_SWC_3_0 = 8;
ADC_TSC.STEPCONFIG1_bit.FIFO_SELECT = 0;

Discussion générale :
Nous avons compilé et testé ce projet pour la lecture d’une entrée analogique. Il est composé de deux codes, l’un pour le PRU 0 qui va lire une valeur sur un pin analogique. Cette partie du code est assez lisible. Ensuite, cette valeur (échantillonnée sur 12 bits) est envoyée au micro-processeur ARM. La communication entre PRU et ARM est assurée par le framework RPMsg (Remote Processor Messaging, voir peut-être ici). Ne connaissant pas ce framework, je vais me rencarder sur ce Graal.
Enfin, le second code, compilé sur mon PC , est exécuté sur la BBB par l’ARM. Celui-ci envoie une requête avec le numéro du canal et reçoit en retour la valeur mesurée. Enfin, celle-ci est convertie en Volts et affichée.

Conclusion :
Nous avons abordé, entre autres, le téléchargement du « pru-software-support-package » de Texas Instruments, l’installation du SDK sur le PC, la compilation des deux codes, l’activation du PRU et enfin nous avons fourni de bons résultats de l’exécution du programme sur ARM.
A noter que le PRU lit une seule valeur sur l’ADC  (one-shot). Il serait intéressant de lire des valeurs à intervalles réguliers et de les renvoyer à l’ARM. Aussi comprendre la communication entre PRU et ARM avec le RPMsg.

Et Voilà !!!

Bien démarrer avec la BeagleBone Black Wireless (BBBw)

Voici quelques tips pour bien démarrer avec la BeagleBone Black Wireless. J’ai acheté ce petit bijou de technologie il y a peu et je partage avec vous mes premiers pas.
La BBB Wireless suppose des manips légèrement différentes pour la prise en main, par rapport à la BeagleBone Black. Il y a beaucoup en commun cela dit. Voici un guide pas à pas des étapes pour démarrer avec votre BeagleBone Black Wireless et la configurer. Après c’est à vous de jouer!

Les premiers pas, décrits dans la page getting-started de BeagleBoard.org sont les suivants:

Télécharger la dernière version de la distribution Debian de Linux sur la page latest-images.
– avec interface graphique (LXQT) https://debian.beagleboard.org/images/bone-debian-9.9-lxqt-armhf-2019-08-03-4gb.img.xz, version Debian 9 « Stretch » mars 2020,
– sans interface graphique (IoT = Internet of Things, si vous travaillez uniquement en ligne de commande) https://debian.beagleboard.org/images/bone-debian-10.3-iot-armhf-2020-04-06-4gb.img.xz, version Debian 10 « buster » avril 2020.

Ensuite,  graver l’image sur une carte micro SD; elle sera ensuite insérée dans le BeagleBone Black (BBB).

Pour cela, il faut installer BalenaEtcher, logiciel pour graver l’image de la distribution Debian de Linux sur la carte micro-SD.
Sous Linux/Debian (OS de votre ordinateur), c’est possible avec apt-get:
sudo apt-get install balena-etcher-electron
Il est également possible de télécharger un installeur:  balenaEtcher.

BalenaEtcher permet de graver l’image du système d’exploitation sur la carte SD.  Il y a un petit trick sous Linux. Dans un terminal, on exécute directement:
balena-etcher-electron
On peut avoir le message d’erreur suivant:
/usr/bin/balena-etcher-electron: ligne 3: /usr/bin/balena-etcher-electron.bin: Aucun fichier ou dossier de ce type
La solution consister à exécuter:
/opt/balenaEtcher/balena-etcher-electron
voir la note dans https://github.com/balena-io/etcher/issues/3074

Ensuite, dans  balena-etcher, on sélectionne l’image Linux téléchargée et le disque contenant la carte mirco-SD, enfin on « flash »! Cela peut prendre un certain temps (4 Go).

Personnellement, j’utilise un adaptateur de carte SD vers USB, pour brancher la carte micro-SD sur l’ordinateur, ce qui est bien pratique.

Étape suivante: insèrer la carte mirco-SD dans le BBB (uSD dans l’image ci-dessous). Puis brancher la BBB sur un port USB de votre ordinateur (avec un câble micro USB inséré dans « USB client » sur la BBB)  . Attention, avant et pendant l’allumage, il faudra appuyer pendant quelques secondes sur le bouton « boot button » pour démarrer sur la carte SD (l’image ci-dessous est une BBB standard, mais la connectique est similaire):

Noter que le démarrage (boot) de la BBB peut prendre quelques minutes.

Étape: se connecter au réseau Wifi local

Cette étape est spécifique à la BeagleBone Black Wireless, dans laquelle le port Ethernet est remplacé par la Wifi.

Normalement, après avoir allumé la BBB, un nouveau réseau Wifi devrait être activé sur votre ordi. La BBB Wireless fonctionne en mode serveur Wifi.

Si votre Beagle comprend le WiFi, un point d’accès appelé « BeagleBone-XXXX » où « XXXX » varie selon les cartes. Le mot de passe du point d’accès est par défaut « BeagleBone ». Votre Beagle doit exécuter un serveur DHCP qui fournira à votre ordinateur une adresse IP dans la plage 192.168.8.x et se réservera 192.168.8.1.

Il faut donc activer, sur votre ordinateur, la connexion Wifi « BeagleBone-XXXX », pour se connecter à la BBB Wireless. Ensuite, ouvrir un terminal (sous Linux ou Mac OS, sous Windows utiliser Putty) et se connecter au BBB avec la commande:
ssh debian@192.168.8.1
login: debian!!!
mot de passe: temppwd (normalement c’est indiqué)

Étape suivante: se connecter au réseau local Wifi

Cette étape est aussi spécifique à la BeagleBone Black Wireless.
C’est très bien décrit ici, (en Anglais), pas à pas. Je ne traduis pas là.
L’objectif est de connecter la BBB à la Wifi de votre box (Livebox, Freebox ou autre). Vous aurez à identifier votre box dans le tuto et à entrer le mot de passe. Après, vous pourrez vous connecter directement à la BBB Wireless avec la Wifi « normale ».
Pour trouver l’adresse ip de votre BBB sur le réseau Wifi, taper
ifconfig
Vous obtenez quelque chose comme ça:

Entouré en rouge, dans wlan0, après inet vous avez l’adresse ip locale de la BBB, 192.168.1.25 dans mon cas. Cette adresse commence par 192.168 (en général 192.168.0.xxx ou 192.168.1.xxx selon la box).
Vous pouvez  vous déconnecter de la BeagleBone:
exit
Sur votre ordinateur, se déconnecter du Wifi de la BeagleBone et se reconnecter à la box si utilisation de la Wifi (je suis connecté en Ethernet).
Pour vous reconnecter à la BBBw:
ssh debian@192.168.1.25
J’ai eu besoin de taper, comme indiqué,
ssh-keygen -f "/home/benaroya/.ssh/known_hosts" -R "192.168.1.25"
(je ne détaille pas la raison) puis retaper ssh debian@192.168.1.25
Noter que la commande suivante fonctionne également:
ssh debian@beaglebone.home
Du coup, on n’utilisera plus la BBB Wireless en serveur Wifi, mais la connexion est simplifiée.

Étape suivante: démarrer directement sur la carte SD (sans appuyer sur le boot button!)
C’est décrit, en Anglais, ici BeagleBone Black Wireless: Boot from SD card by default.
Vous trouverez une explication similaire, in French, dans le fichier bootingonsdcard. C’est un peu différent parce que nous avons « booté » sur la carte SD.

Élargir la carte SD de plus 4 Go

Pour une carte micro-SD de plus de 4 Go, il faut faire la manipulation suivante. Par défaut, il y a une limitation à 4 Go sur la BBB, ce qui est dommage quand on a une carte SD de 32 Go, comme moi.
La solution:
Le script « grow_partition.sh » permet de faire ça.
sudo /opt/scripts/tools/grow_partition.sh
sync
Si problème, le script est accessible dans le repo github https://github.com/RobertCNelson/boot-scripts/blob/master/tools/grow_partition.sh Je remets le script à disposition
Ensuite, il faudra redémarrer la BBB. Note: pour redémarrer un Linux en ligne de commande:

sudo reboot now

2 TIPS

Vérifier la date avec la commande « date » (une date mal réglée peut causer des problèmes d’update parfois):
date
Changer de fuseau horaire
timedatectl set-timezone Europe/Paris
ou pour nos amis Canadiens
timedatectl set-timezone America/Toronto
Nettoyer le système,
sudo apt-get clean
sudo apt-get autoremove
sudo apt-get update

Discussion :

La BeagleBone Black est intéressante pour les systèmes embarqués. Elle contient un micro-processeur Cortex-A8 à 1 Ghz (jeu d’instructions ARMv7) et deux microcontrôleurs PRU 32-bits (Programmable Real-time Unit) à 200 Mhz.
Par rapport à la Raspberry Pi, elle possède un autre avantage, la possibilité d’installer différentes distributions de Linux (Debian, Ubuntu) ou un Androïd (entre autres). L’OS standard de la Raspberry Pi (RPI), Raspbian, est une version adaptée de Debian.
L’avantage de la RPI est indéniablement la RAM (1 Go à 4 Go pour la RPI 4 contre 512 Mo pour la BBB) et ça peut faire une vraie différence pour des programmes gourmands en mémoire. Par ailleurs, la connectique USB est beaucoup plus intéressante. En mode ordinateur mono-carte, avec un écran, un clavier et une souris, utiliser une Raspberry Pi fait sens.
Concernant la BeagleBone Black Wireless, par rapport à la BBB standard, la Wifi est intéressante, pour installer des programmes facilement (apt-get install). Après est-ce que la différence de prix (de l’ordre de 20 €) se justifie? Vous me direz qu’on peut toujours ajouter un dongle USB sur la BBB. Mais il n’y a qu’un seul connecteur USB, donc le hub USB devient obligatoire, pas vraiment pratique.
J’utilise la BBBw branchée sur mon PC via le client USB (comme pour un Arduino), voulant explorer les possibilités de traitements temps-réel sur du son. Pour le moment, je suis content de mon achat. J’ai galéré quelque peu pour l’installation et la mise en place. J’espère que ce post permettra de vous aider et vous guider dans la prise en main.

ET VOILA!!!!

Comment classifier des images sur une Raspberry pi 3? TensorFlow Lite

Bonjour à tous,

Dans mon précédent post, j’explique comment installer TensorFlow 2 sur Raspberry Pi (RPI).

Je me suis rendu compte qu’en fait, il suffit d’installer TensoFlow Lite pour faire de la classification d’image à partir de réseaux de neurones pré-entraînés.

L’avantage, c’est que l’installation est beaucoup plus « lite » et que c’est très simple.

Tout est expliqué (en Anglais), là : TensorFlow Lite Python classification example with Pi Camera .

Et l’installation de TensorFlow Lite est expliquée ici : Python quickstart .

Le seul « trick » que je pourrais ajouter, c’est que perso, ce coup là j’ai utilisé Miniconda pour me créer un environnement virtuel avec Python 3.6 . J’en parle un peu dans mon précédent post. Dans ce cas, « pip install numpy » (dans les requirements.txt) ne marche pas, alors que « conda install numpy » fonctionne.

On peut lancer le code pour la classification automatique d’image :

python3 classify_picamera.py --model /tmp/mobilenet_v1_1.0_224_quant.tflite --labels /tmp/labels_mobilenet_quant_v1_224.txt

C’est vraiment super !!!

Pour comprendre, TensorFlow Lite prend quelques centaines de millisecondes pour classifier une image provenant du flux vidéo, tandis que TensorFlow mettra plusieurs secondes. Cela est dû en partie au fait que le modèle Lite est quantifié sur 8 bits (sauf erreur de ma part). Au lieu de nombres à virgule flottante (float) codés sur 32 bits, on utilise des entiers sur 8 bits, ce qui réduit la taille (en octets) du modèle et surtout accélère considérablement le temps de calcul. Les résultats sont un peu moins précis en principe.

Voici une version un peu modifiée de la démo classify_image.py qui permet de classifier une seule image :

curl -O https://storage.googleapis.com/download.tensorflow.org/models/tflite/mobilenet_v1_1.0_224_quant_and_labels.zip
unzip mobilenet_v1_1.0_224_quant_and_labels.zip
python classify_image.py --model mobilenet_v1_1.0_224_quant.tflite --labels labels_mobilenet_quant_v1_224.txt --image monimage.jpg

Les deux premières lignes téléchargent et dé-zippent le modèle. « classify_picamera.py » est remplacé par « classify_image.py ». Notez l’option supplémentaire –image qui permet de fournir un fichier image au lieu d’utiliser la camera du RPI.

Et voilà!!!

Comment installer TensorFlow version 2 sur Raspberry Pi : la compilation croisée ?

classifier des images Sur ma Raspberry pi 3 avec un réseau de neurones profond sous Python 3

L’objectif est de classer des images depuis une Raspberry 3, en utilisant la camera « rapstill » dédiée. Une application potentielle est la prise de photos, en envoyant à un serveur distant uniquement les images d’animaux (par exemple). Nous souhaitons, pour cela, utiliser des outils du « Deep Learning », avec des réseaux de neurones profonds pour la classification des images.

A noter que la Raspberry 3 B+ a des ressources limitées en terme de mémoire vive [1 Go de RAM]. De plus, son processeur de type ARM est différent de celui sur un PC (x86).

premier essai d’installation de tensorflow et de keras

On travaille sous python 3.x sur une Raspberry Pi 3 B+.

Keras est un paquet Python qui permet de créer, d’entraîner et de tester des réseaux de neurones profonds (DNN = Deep Neural Network). Keras est intéressant car il y est facile et rapide de mettre en œuvre des DNNs par rapport aux alternatives. A la base, Keras est une couche haut niveau qui utilise des logiciels d’optimisation comme TensorFlow ou Theano. Dans cet article, on se concentre sur TensorFlow avec la « sur-couche » Keras « au-dessus ».

L’installation de TensorFlow version 1, sur la Raspberry, se fait avec l’outil « pip ». Malheureusement, ça bloque côté Keras et en particulier sur la compilation du paquet « scipy » version 1.4.1 (scientific python).
Pour compiler scipy depuis les sources, sur la Raspberry, il est conseillé d’augmenter la taille du swap (définition du swap, comment augmenter sa taille), mais les 1Go de RAM ne suffisent pas.

Le paquet compile pendant une heure et demi, puis plus rien : pas de message d’erreur, mais il ne se passe plus rien. En googlant un peu, je me rends compte que je ne suis pas le seul à galérer sur le problème.

J’abandonne momentanément mon objectif.

TensorFlow 2

A travers d’autres projets, je commence à utiliser TensorFlow dans sa version 2. Je code par exemple une factorization en matrices non négatives (NMF) en utilisant TensorFow (TF) comme un outil d’optimisation performant. Génial.
Le truc vraiment génial, c’est que TensorFlow 2 intègre entièrement Keras.

Je comprends que si j’arrive à installer TensorFlow 2 sur la Raspberry Pi (RPI), j’ai gagné la partie, ou du moins je marque un bon point.

classification d’images de la base imagenet

Parallèlement, sur mon PC de bureau, je m’intéresse à la classification d’images avec TF 2/ Keras. Mieux vaut tard que jamais! J’utilise la base d’images ImageNet, qui est géniale car elle contient 1000 classes d’objets visuels. Pour la classification, j’utilise Inception v3, qui est intégré à TF 2 (tf.keras.applications.InceptionV3). C’est un gros réseau de neurones profond.
Les résultats sont bluffants.
En passant, je remarque qu’il existe une version light du modèle Inception v3 (entre autres!) avec TF Lite, ou du moins la possibilité d’en créer.
Je range ça quelque part dans ma mémoire.

Pour la petite histoire, J’ai montré les performances de classification avec la base ImageNet et Inception, à ma compagne le soir même. Pas vraiment enthousiaste. Moi je trouve ça génial. Je sais que c’est un des premiers gros succès du Deep Learning (apprentissage profond).
Pour se faire une idée, lorsque je joue à pile ou face, j’ai deux cas. Le hasard me donne une probabilité de 1/2 = 50% par face.
Donc si je suis capable de prédire un peu mieux le résultat (par exemple si la pièce est bizarrement faite et que le jeu est pipé, c’est un peu tordu mais bref), prédire ne serait-ce qu’à 51% d’accuracy, je fait mieux que le hasard et ça déjà c’est très fort. ça ne paraît pas comme ça, mais ça fait une vraie différence. Au passage, l’accuracy est un terme anglais qui désigne le pourcentage d’items correctement classés.

Dans la base de données ImageNet,  il y a 1000 classes (explore), regroupées de manière hiérarchique dans les macro-classes suivantes :

  • Plant, flora, plant life,
  • Geological formation, formation,
  • Natural object,
  • Sport, athletics,
  • Artifact, artefact,
  • Fungus,
  • Person, individual, someone, somebody, mortal, soul,
  • Animal, animate being, beast, brute, creature, fauna,
  • Misc.

Pour 1000 classes, le hasard c’est 1/1000, soit 0.1 %. Avec le Deep Learning, on atteint des résultats de l’ordre de 70 à 80% d’accuracy, sur un ensemble de TEST (c-a-d différent de l’ensemble d’apprentissage). Passer de 0.1% à 70%, c’est hallucinant!

Exemple artichaut ! (image trouvée sur le net)

Résultat avec Inception v3

artichoke,		probability = 92.3%
cardoon,		probability = 0.4%
jack-o'-lantern,	probability = 0.1%
grocery_store,		probability = 0.1%
Dutch_oven,		probability = 0.0%
retour au Raspberry
les versions de Python

Il est possible d’installer Miniconda sur la RPI, à la main. C’est une version light d’Anaconda et qui permet de créer des environnements virtuels pour python de manière simple. Avec un environnement virtuel, on peut installer python et pleins de paquets/modules, modifier des bouts de code, faire port-nawak. ça n’est pas grave. Il suffit d’effacer l’environnement et le système est indemne. C’est le principe de la virtualisation.
Avec Miniconda pour la RPI, la version de Python est 3.4. Or TF 2 nécessite une version de Python supérieure ou égale à 3.5.
Il est possible d’installer Python 3.6 avec Berryconda.
Pour cela, taper dans un terminal de votre Raspberry:
conda config --add channels rpi
puis pour créer l’environnement avec Python 3.6
conda create -n py36 python=3.6
Pour activer environnement virtuel avec python 3.6
conda activate py36
pour en sortir
conda deactivate [et pas deSactivate]

J’ai fait le choix d’installer localement Python 3.7, non disponible avec Miniconda.
Pour cela, j’ai compilé les sources sur la RPI. On va suivre l’article Installing Python 3.7.2 on Raspbian :
Dans un terminal, installer les paquets nécessaire à la compilation
sudo apt-get update -y
sudo apt-get install build-essential tk-dev libncurses5-dev libncursesw5-dev libreadline6-dev libdb5.3-dev libgdbm-dev libsqlite3-dev libssl-dev libbz2-dev libexpat1-dev liblzma-dev zlib1g-dev libffi-dev -y

Télécharger les sources [note: la marche à suivre est la même pour une autre version de Python, en fournissant l’url adéquate pour wget]
wget https://www.python.org/ftp/python/3.7.2/Python-3.7.2.tar.xz
tar xf Python-3.7.2.tar.xz
cd Python-3.7.2

Les compiler : 1ère option, globale
./configure
make
make install
2ème option, locale.
créer un répertoire  « py37 » dans « /home/pi » puis
./configure --prefix=/home/pi/py37
make
make install

Dans le second cas, pour utiliser python3 et pip3, c-a-d pour activer python 3.7, il faudra taper dans la console:
export PATH=/home/pi/py37/bin:$PATH
et utiliser pip3 et python3
Note: on pourrait placer une fois pour toute la ligne "export ..." à la fin du fichier "/home/pi/.bashrc"
Si cela vous paraît obscure, utilisez la première solution (globale).

Le coup de bol

En cherchant à installer TF 2 sur Raspberry 3, je suis tombé, avec un peu de chance, car il est tard, sur le repo github de Leonardo Lontra alias lhelontra. [github est un dépot de programmes/codes sources, énorme et très très utilisé.]

Le code source « https://github.com/lhelontra/tensorflow-on-arm » permet de faire la compilation croisée.
Cela signifie qu’on va pouvoir compiler TF sur une machine puissante, comme mon PC de bureau et le résulat sera utilisable sur la RPI et non sur mon PC. On parle de cross-compilation ou compilation croisée. Contrairement au Rapsberry, mon PC a 8 Go de mémoire et un processeur i5 avec 4 coeurs (c’est un PC, sous linux, datant de 2016).

Bon je spoile : la compilation croisée a duré 7 heures et ça a marché!!! Je viendrais tout de suite à la marche à suivre.

Mais en écrivant ces lignes, je m’APRECOIS qu’il y a des versions cross-compilées déjà disponibles dans le repo github.
Quel imbécile je fais!

Alors ce qu’on peut faire, c’est allumer son RPI et lancer un navigateur web et un terminal.
Dans le repo (https://github.com/lhelontra/tensorflow-on-arm), il suffit de cliquer sur l’onglet « releases » (voir image ci-dessous) ou bien taper dans la barre de navigation https://github.com/lhelontra/tensorflow-on-arm/releases .


Ensuite, en dessous de TENSORFLOW 2.0, on clique sur « tensorflow-2.0.0-cp37-none-linux_armv7l.whl » et on l’enregistre.


dans Le nom de ce fichier Wheel, « tensorflow-2.0.0 » c’est pour TF 2.0.0 (!), « cp37 » pour Python 3.7 et « linux_armv7 » c’est pour une architecture linux avec un processeur ARM 7, qui correspond à l’architecture et le processeur du Raspberry pi 3. Pour comprendre, sur un PC le processeur peut-être un i3 ou un i5 ou un pentium. Dans tous les cas, c’est un processeur « x86 ».

Installation de tensorflow 2 sous RPI

On ouvre un terminal dans le Raspberry et on se place là où tensorflow-2.0.0-cp37-none-linux_armv7l.whl a été téléchargé (en général, /home/pi/Downloads),
taper
cd /home/pi/Downloads
puis
pip3 install tensorflow-2.0.0-cp37-none-linux_armv7l.whl
Et c’est tout! Job’s done.

La compilation croisée

SUR NOTRE SUPER PC, sous LINUX :

On va installer « DOCKER » (outil de virtualisation pour le système en entier). Cela permettra d’éviter des conflits entre des librairies ou des composants manquants par exemple. J’ai fait un essai sans docker et ça a planté au bout de 20 minutes. Donc avec Docker c’est mieux.
Pour installer Docker (voir https://docs.docker.com/install/linux/docker-ce/debian/).
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io
Perso, j’ai installé docker avec dpkg, pour une raison qui m’échape (il était vraiment tard!), mais les commandes ci-dessus doivent fonctionner.

ENSUITE,
On télécharge le code source du repo de lhelontra, avec git:
sudo apt-get install git -y [on installe l’outil git si nécessaire]
git clone https://github.com/lhelontra/tensorflow-on-arm.git
cd tensorflow-on-arm

On lit ce qui est indiqué dans la section « Cross-compilation » du repo de lhelontra :

On ajoute l’architecture ARM aux repos debian:
sudo dpkg --add-architecture armhf
la seconde ligne est un peu problématique parce qu’on veut ajouter la ligne
deb [arch=armhf] http://httpredir.debian.org/debian/ buster main contrib non-free
dans le fichier « /etc/apt/sources.list »
La solution choisie, bien que très mal, est de passer en ROOT avant de taper la commande :
sudo su -
echo "deb [arch=armhf] http://httpredir.debian.org/debian/ buster main contrib non-free" >> /etc/apt/sources.list
exit

Ensuite
cd build_tensorflow/
sudo docker build -t tf-arm -f Dockerfile .      [utiliser sudo et ne pas oublier le .]

Avant de lancer la dernière commande, on peut éditer le fichier de configuration « rpi.conf » qui se trouve dans le sous-répertoire « configs ».
On vérifie la ligne
TF_VERSION= »v2.0.0″ [version de tensorflow]

On lance la compilation, en remarquant qu’on peut choisir la version de Python (--env TF_PYTHON_VERSION=3.7)
sudo docker run -it -v /tmp/tensorflow_pkg/:/tmp/tensorflow_pkg/ --env TF_PYTHON_VERSION=3.7 tf-arm ./build_tensorflow.sh configs/rpi.conf

La compilation peut durer plusieurs heures (7 heures pour moi), donc à lancer la nuit de préférence.
On obtient finalement un fichier « tensorflow-2.0.0-cp37-none-linux_armv7l.whl » dans le répertoire /tmp/tensorflow_pkg/

On le recopie ensuite sur le Raspberry Pi.
Une fois sur le RPI, il restera à faire un « pip3 install tensorflow-2.0.0-cp37-none-linux_armv7l.whl » pour l’installation sur le RPI, comme indiqué plus haut.

L’intérêt de discuter de la compilation croisée, outre de comprendre un peu le dessous des cartes, c’est que ça peut être utilisé pour créer le fichier wheel pour une autre architecture comme le Beagle Bone Black par exemple (choisir le fichier de config « beagle_black.conf »), pour laquelle il n’y a pas de « release ».

Pour finir, ce post décrit comment installer TensorFlow 2 sur une Rapberry pi 3. Dans sa version la plus simple, il suffit d’installer, sur le RPI, Python 3.7 et de télécharger le fichier wheel adéquat pour TF 2 depuis https://github.com/lhelontra/tensorflow-on-arm/releases .
On peut aussi cross-compiler sur un PC plus puissant, sous linux, avec pour cible d’autres appareils comme le Beagle Bone Black, ou pour utiliser une autre version de Python (>=3.5) pour la RPI.

Et voilà!

Les fichiers audio dans LTspice pour la simulation d’effets

Cet article explique comment importer et exporter des fichiers audio (au format wav) dans LTspice.
Cela est très intéressant pour tester un effet analogique et simuler par exemple le rendu d’une pédale de guitare!

Commençons par un montage de base avec un AO:

baseInv

C’est un amplificateur inverseur. Comme R1 = R2, c’est un inverseur simple.

L’AMPLIFICATEUR OPERATIONNEL

Pour l’ampli op, on a choisi un ampli op standard LM741. 

Je passe rapidement sur les détails techniques : on utilise le fichier LM741.sub et on ajoute la directive
« .lib C:\monchemin\LM741.sub »
On renomme opamp2 en LM741/NS.

LM741

Il reste à ajouter une alimentation symétrique en -4.5v, +4.5V pour alimenter l’AO. On utilise pour cela deux « cells » avec les labels V+ et V- :alimA0

Ci-joint le circuit inverseur.

AJOUT D’UN FICHIER AUDIO EN ENTREE

Le « trick », c’est de presser la touche « ctrl » tout en cliquant droit sur le générateur de tension (le composant « voltage »):

EntreeWav1

Dans le champ « value », on utilise le mot clef wavefile
wavefile= »C:\monchemin\monfichier.wav » chan 0
chan 0 indique de prendre le premier canal, en cas de fichier stéréo.
EntreeWav2
Ci-joint le fichier audio (enregistré avec un smartphone de base) : say it aint so extrait . Ce fichier dure environ 15.2 secondes. Dans la « simulation command », on ajuste la durée à 15.3 secondes.

ENREGISTREMENT DU FICHIER AUDIO EN SORTIE

On ajoute pour cela une directive avec le mot clef .wave :
.wave « C:\monchemin\monfichierWavOut.wav » 16 44100 Vout

  • .wave : pour indiquer que la sortie est un audio au format wav,
  • « C:\… » : le nom du fichier de sortie,
  • 16 : nombre de bits de quantification – 16 bits est la valeur standard,
  • 44100 : fréquence d’échantillonnage en Hz, c’est à dire le nombre de valeurs par seconde. 44100, c’est la qualité CD,
  • Enfin, Vout est le label qui correspond à la sortie.
  • SortieWav

SIMULATION D’UN EFFET PASSE-BAS

Pour que cela devienne intéressant, on transforme notre circuit inverseur en un passe-bas par l’ajout d’une capa en parallèle de la résistance R2.

SortieWavPasseBas

La fréquence de coupure du passe-bas est 1/(2*pi*R2*C1). Avec C1=160n, cette fréquence est d’environ 1kHz.

On lance la simulation. Notez bien que la simulation demande une latence considérable. Il est conseillé de tester son circuit sur des fichiers courts.

Ci-joint, le fichier audio en sortie du passe-bas : say it aint so extrait passe base 1kHz .

CONCLUSION

L’audio en entrée et en sortie, la possibilité de simuler des effets analogiques. Rien à dire : LT spice c’est génial!

P.J. : le schéma spice pour le passe-bas avec audio en entrée et sortie : PB

Compiler le code source de TensorFlow avec les optimisations AVX2 et FMA sous Mac OS X

Ce post concerne l’installation du paquet TensorFlow à partir du code source.

La motivation première est d’éviter ce warning :

"The TensorFlow library wasn't compiled to use AVX2 and FMA instructions, but these are available on your machine and could speed up CPU computations."

Pour contextualiser, je travaille sur un MacBook Pro 2017:

MacBook Pro (13-inch, 2017, Two Thunderbolt 3 ports)
Processeur 2.3 GHz Intel core i5 (2 coeurs)
Mémoire 8 Go 2133 MHz LPDDR3
Graphisme Intel Iris Plus Graphics 640 1536 Mo

Donc pas de GPU.

L'objectif est de compiler TensorFlow « nativement » pour ma machine, ce qui a priori devrait être mieux optimisé et donc plus performant en temps de calcul que l’installation standard par « pip install tensorflow ».

Cet article est principalement inspiré de la documentation de TensorFlow : https://www.tensorflow.org/install/source.
Je suis parti en fait de ce « post » : https://gist.github.com/winnerineast/05f63146e4b1e81ae08d14da2b38b11f, dans lequel il manque cependant des prérequis avant la compilation.
Enfin, la compilation sous Mac OS fait appel à « Bazel ». Son installation est expliquée là : https://docs.bazel.build/versions/master/install-os-x.html.

Dans un premier temps, j’explique l’installation d’Anaconda et la mise en place d’un environnement virtuel.
Ça n’est pas directement lié à notre problème, mais cela permet de poser le contexte.

Anaconda

Installation

Il faut aller là https://www.anaconda.com/distribution/ et cliquer sur le lien 64-Bit Command Line Installer (435 MB) - installation en ligne de commande.

Ensuite ouvrir un terminal et aller dans le répertoire Downloads

$ cd Downloads

Lancer l’installation

$ bash Anaconda3-2019.07-MacOSX-x86_64.sh

Création d’un environnement virtuel (python 3.6)

$ conda create --name py36 python=3.6 anaconda

Quand on veut activer l’environnement virtuel dans un terminal

$ source activate py36

Pour sortir de l’environnement

$ conda deactivate
On revient à nos moutons : taper

$ source activate py36

Puis

$ conda update numpy (inutile a priori puisqu’on vient d’installer l’environnement py36, mais ça peut servir s’il est déjà installé).

ON REVIENT A LA COMPILATION

 

ATTENTION, à ne pas oublier.

Il faut installer deux paquets avant la compilation sous peine de générer des erreurs.

$ source activate py36 (si ce n’est pas déjà fait)

$ pip install -U keras_applications==1.0.6 --no-deps

$ pip install -U keras_preprocessing==1.0.5 --no-deps

Pas besoin de l’option «--user » parce qu’on est dans un env. virtuel.

INSTALLATION DE BAZEL

« install Bazel using binary installer » tel que décrit dans https://docs.bazel.build/versions/master/install-os-x.html

Dans le GitHub, sélectionner la version 0.26.1 https://github.com/bazelbuild/bazel/releases/tag/0.26.1 puis télécharger le fichier bazel-0.26.1-installer-darwin-x86_64.sh

Enfin installer :

$ cd Downloads

$ bash bazel-0.26.1-installer-darwin-x86_64.sh --user

Attention, il est important que la version de Bazel soit <= 0.26.1

TELECHARGEMENT DU CODE SOURCE DE TENSORFLOW

$ git clone https://github.com/tensorflow/tensorflow.git

$ cd tensorflow

$ git checkout r1.14

La dernière ligne indique que l’on utilise la version/branche 1.14 de TensorFlow

COMPILATION

$ source activate py36 (si ce n’est pas déjà fait)

$ ./configure

Garder les options par défaut dans la configuration.

En particulier, l’option « march=native » indique que la compilation est faite pour votre Mac.

$ bazel clean

$ bazel build -c opt --copt=-mavx2 --copt=-mfma  -k //tensorflow/tools/pip_package:build_pip_package

ATTENTION LA COMPILATION PEUT PRENDRE DU TEMPS, PLUSIEURS HEURES SUR MA MACHINE.

CONSTRUIRE LE PAQUET

$ ./bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg

INSTALLER LE PAQUET avec pip

$ pip install /tmp/tensorflow_pkg/tensorflow-1.14.1-cp36-cp36m-macosx_10_7_x86_64.whl

Test pour vérifier que TensorFlow fonctionne

Sortir du dossier tensorflow :
$ cd

$ source activate py36 (si besoin)
$ python
Python 3.6.9 |Anaconda, Inc.| (default, Jul 30 2019, 13:42:17) 
[GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow as tf
>>> a = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[2, 3], name=‘a')
>>> b = tf.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape=[3, 2], name=‘b')
>>> c = tf.matmul(a, b)
>>> with tf.Session() as sess:
        print (sess.run(c))
        aa = sess.run(a)
        bb = sess.run(b)
>>> print(aa.dot(bb))

Et voilà!

Comment enlever la musique de fond dans le tts Acapela (text to speech)?

Dans ce post, je vais expliquer comment retirer la musique de la parole, dans l’audio généré dans la démo de Acapela. Nous allons enregistrer le flux audio généré avec Audacity et en utiliser un programme home-made en python pour la séparation parole/musique.

Acapela permet faire de la synthèse de la parole à partir du texte ou encore TTS – Text To Speech. Il y a plein de voix possible et le truc marche super bien.
Acapela propose une version de démonstration avec une limite de temps sur l’audio généré et avec la musique ajoutée à la parole.

Pour sauvegarder la parole et retirer la musique de fond, il va falloir :

  1. entrer une phrase dans le TTS dans Acapela demos.
  2. enregistrer le flux audio avec Audacity et générer la phrase
  3. sauvegarder l’audio dans Audacity en faisant attention de le mettre en 22050 Hz.
  4. télécharger l’application appcapela qui est une interface graphique (GUI) en python 3, qui va permettre de séparer la parole de la musique.

On va enregistrer un flux audio avec Audacity. Ceci est détaillé dans l’article Enregistrer vos flux audio avec Audacity sous Windows  Il faut:

  1. taper « peripherique » dans la case en bas à gauche de Windows, choisir « gérer les périphériques audio ». Dans l’onglet « enregistrement », cliquez droit sur « mixage stéréo » et puis « activer » et « définir comme périphérique par défaut ».peripherique-enregistrement
  2. lancer Audacity, changer les options d’enregistrement:Audacity_wasapi2
    1. sélectionner « Windows WASAPI »
    2. à côté du microphone choisir « xxx (loopback) ». Dans mon cas, c’est « OUT (UA – 25EX (loopback) » parce que j’ai une carte son USB UA-25EX. L’important, c’est « loopback » qui permet de récupérer le flux audio.
    3. Choisir « 1 (Mono) Recording Channel », pour enregistrer en mono.
    4. Important, choisir une fréquence d’échantillonnage de 22050 Hz!
      Audacity_22kHz
      On peut toujours ré-échantillonner avec ffmpeg, avec la commande
      « ffmpeg -i monfichier.wav -ar 22050 monfichier_22050.wav ».
      Je ferai peut-être un post sur l’utilisation de ffmpeg sous Unix et sous Windows (plus tricky).
    5. Lancer l’enregistrement (bouton rouge en haut)
    6. Lancer le flux à enregistrer, comme YouTube par exemple. Dans notre cas, ce sera la démo de Acapela.
    7. Stopper l’enregistrement
    8. Nettoyer l’enregistrement avec l’outil ciseau Audacity_ciseau
    9. Enfin exporter l’audio.Audacity_export

Installer python/ Anaconda3

Le programme permettant de séparer la voix de la musique est écrit en Python. Il va donc falloir installer Python (version 3.x) avec Anaconda. Télécharger aussi le programme qui se trouve dans « GitHub ».

  1. télécharger Anaconda3 et l’installer.
    Anaconda pour Python 3
  2. La version 3.7 de Python s’avère être incompatible avec le paquet « wxpython-phoenix » qui se charge de l’interface graphique. On va donc créer un environnement virtuel pour python 3.6. C’est la bonne manière de procéder. Pour cela, on ouvre une fenêtre DOS en tapant « cmd » en bas à gauche de l’écran Windows (là où il y est écrit « Tapez ici pour rechercher »), puis entrée/return.
    Dans la fenêtre de commande, tapez conda create –name py36 python=3.6 anaconda (création de l’environnement)
  3. activer l’environnement en tapant « activate py36 » dans la fenêtre de commande. Sous Linux ou Mac Os, ce serait « source activate py36 ».
  4. Télécharger appcapela
    Aller dans mon repo « LaurentNorbert » dans GitHub : appcapela et télécharger :download_appcapela
    puis décompresser l’archive.
  5. Pour lancer appcapela :
    1. lancer la fenêtre de commande en tapant « cmd » en bas à gauche dans la barre Windows et taper entrer/return pour la lancer.
    2. si c’est une nouvelle fenêtre de commande, tapez « activate py36 ».
    3. installer les paquets en ligne de commande en tapant:
      1. conda install -c newville wxpython-phoenix
      2. pip install resampy
      3. pip install soundfile
    4. aller dans le répertoire dans lequel on a décompressé l’archive. Si le répertoire est « C:\Users\laure\Downloads\appcapela-master\appcapela-master », alors tapez « cd C:\Users\laure\Downloads\appcapela-master\appcapela-master ».
    5. taper « pythonw appcappella.py » pour lancer l’application.
      Attention il faut utiliser pythonw et non python, parce que c’est une application graphique (GUI).ihm
    6. Dans l’interface graphique :
      1. cliquez sur le bouton « model and speech output folder » et sélectionnez le répertoire outputandmodel.
      2. cliquez sur le bouton « noisy file » et choisissez le fichier audio que vous souhaitez dé-bruiter.
      3. cliquez sur « process file », attendez qu’un popup vous indique que le traitement est terminé.
      4. le fichier traité se trouve dans le répertoire outputandmodel

DONE !!!!

Connecteurs

Bonsoir,

Voici un petit article sur les connecteurs de la marque Molex.
D’après wikipedia, ce sont des connecteurs qui sont utilisés pour l’alimentation des disques durs, des lecteurs CD/DVD et des ventilateurs dans les ordinateurs.

Voici une photo que j’ai récupérée sur la page de Molex de wikipedia.

220px-Molex1

Je me suis dit « je connais! C’est dans mon PC ». Je ne sais pas si ça fait de moi un geek.

Enfin, voilà. Ce que je trouve génial, et qui est expliqué dans l’article wikipedia, c’est que l’entreprise Molex, fondée en 1938, fabriquait initialement des pots de fleurs en plastique!

Une belle aventure industrielle…