X-Sens Dot Sensor

Dans le cadre d’un projet de recherche, j’ai testé un senseur de chez X-Sens: X-Sens Dot :

Ce capteur doit permettre de remonter des informations accélération pour l’expérience. Devant la documentation en ligne sur ce dispositif et avec l’accord du support très réactif de l’entreprise X-sens, je pense qu’un tutoriel plus complet sur ce dispositif peut être utile au plus grand nombre.

Des informations actuellement que je dispose, je n’ai pas trouvé de solution pour connecter mon Windows 10 sur le X-Sens, le développement se fait via mon smartphone android (un samsung S10+) et avec Android Studio.

Je ne peux que vous conseiller de télécharger l’application officielle (xsensdot-apk-v2020.0.apk en Avril 2020) de X-Sens pour les X-Sens Dot et le SDK X-Sens Dot dans la rubrique Software/Wearable Sensor: https://www.xsens.com/software-downloads

Le SDK contient une documentation PDF et .chm et un fichier XsensDotSdk.aar qui a servi de base à ce tutoriel.

 

1/ Démarrage d’Android Studio

En premier lieu créons dans Android Studio un nouveau projet se basant sur une Activity vide:

Configuration du projet avec un nom, un nom de package, un dossier de stockage et surtout une version de SDK minimale à API 22 selon les recommandations de la documentation:

En premier ajoutons les droits spécifiques et nécessaire sur cette application, il est à noter que je déploie sur un smartphone réel et non vers l’émulateur. Je trouve que c’est plus rapide et plus efficace de développer sur un smartphone réel en suivant ces recommandations sur developer.android.com.

Ajoutons donc ces permissions, qu’il faudra activer aussi sur le smartphone individuellement pour Storage et Position (voir plus bas dans le tutoriel):

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

 

2/ Importation de XsensDotSdk.aar

L’importation d’un module aar se fait en plusieurs étapes que j’ai découvert avec ce projet.

En premier lieu, il faut indiquer l’importation de ce module via le Menu File > New > New Module … puis choisir « Import .JAR/.AAR Package » , faire Next:

 

Indiquer le chemin vers le module XsensDotSdk.aar (pour le nom du subproject le laisser par défaut):

Ce n’est pas parce que le module est importé en tant que subproject que notre projet a une dépendance envers lui.

Donc, Menu File > Project Structure … > puis Dependencies > app (notre projet par défaut) puis le petit bouton + (Add Depency) puis choisir « Module Depency » :

 

 

 

Indiquons que l’on veut une dépendance vers XsensDotSDK, Ok pour valider cette fenêtre et ensuite de nouveau OK pour valider la fenêtre précédente:

Une phase de build se déclenche plus ou moins longue selon la performance de son ordinateur…

 

3/ Utilisation des classes du  XsensDotSdk.aar

Nous allons travailler dans ce tutoriel sur la MainActivity, ce n’est pas l’idéal mais pour un développement de test nous pouvons réaliser un premier essai.

Ajoutons l’implémentation des classes XsensDotDeviceCv et XSensDotScannerCb:

Nous avons une erreur d’importation que l’on règle en laissant la souris sur les 2 classes problématiques, IntelliJ nous propose d’importer les packages manquants:

Nous pouvons maintenant aussi fabriquer les implémentations manquantes pour les méthodes nécessaires aux classes XsensDotDeviceCv et XSensDotScannerCb en survolant avec notre curseur ces dernières:

 

L’ajout de toutes les méthodes se fait rapidement:

 

 

4/ Développement des fonctions de connexion au X-sens DOT

Nous allons donc coder dans la méthode onCreate encore une fois par simplicité puis nous détecterons que le smartphone a bien trouvé le X-Sens Dot en mettant un point d’arrêt dans la méthode onXsensDotScanner:

public void onXsensDotScanned(BluetoothDevice bluetoothDevice) {

Donc on code une propriété mxScanner

private XsensDotScanner mXsScanner;

Puis dans la méthode onCreate :

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    String version = XsensDotSdk.getSdkVersion();
    XsensDotSdk.setDebugEnabled(true);
    XsensDotSdk.setReconnectEnabled(true);
    mXsScanner = new XsensDotScanner(this.getApplicationContext(), this);
    mXsScanner.setScanMode(ScanSettings.SCAN_MODE_BALANCED);
    mXsScanner.startScan();
}

 

Enfin un bout de code pour récupérer les informations sur le device:

@Override
public void onXsensDotScanned(BluetoothDevice bluetoothDevice) {
    String name = bluetoothDevice.getName();
    String address = bluetoothDevice.getAddress();
}

Choisissez ensuite votre smartphone (il faut que le débuggage soit possible sur ce smartphone d’ailleurs cf developer.android.com) puis le bouton « débug app » :

Voici les indications de débugage avec les adresses (factice sur cet écran) de réponse:

Ajoutons maintenant la récupération des données par le capteur en ajoutant une nouvelle propriété et  en modification la méthode onXsensDotScanned:

Nouvelle propriété: xsDevice pour gérer la connexion à notre Xsens Dot

private XsensDotDevice xsDevice = null;

 

Nouvelle version de onXsensDotScanned

@Override
public void onXsensDotScanned(BluetoothDevice bluetoothDevice) {
    String name = bluetoothDevice.getName();
    String address = bluetoothDevice.getAddress();

    xsDevice = new XsensDotDevice(this.getApplicationContext(), bluetoothDevice,MainActivity.this);
    xsDevice.connect();
    xsDevice.startMeasuring();
}

Notre X-Sens Dot devrait capture les données dans la méthode onXsensDotDataChanged et l’envoyer dans le loger LogCat d’Android:

@Override
public void onXsensDotDataChanged(String address, XsensDotData xsensDotData) {
    Log.i( "XsensDot", "onXsensDotDataChanged " + address + " " + xsensDotData );
}

 

Nous lançons le débugage avec un point d’arrêt sur l’évènement onXsensDotDataChanged et un regard sur le LogCat dans IntelliJ:

Aucune donnée n’arrive sur la méthode onXsensDotDataChanged….

 

5/ Ajout des droits dans le smartphone

Les données n’arrivent pas car il faut ajouter les droits sur l’application directement sur ce dernier. j’avais eu déjà le problème avec les IMU embarquées dans le smartphone.

Il faut donc aller sur l’application, faire un appuie long, puis choisir « Infos sur l’appli. » puis dans l’écran « informations sur l’application » choisir le menu « Autorisations » puis accepter les 2 autorisations « Localisation » et « Stockage » pour enfin pour relancer l’application avec les droits complets:

Et donc récupération des données sur un point d’arrêt du débug quand les données arrivent:

 

6/ Liaison Xsens DOT – Smartphone Android – Code JAVA

Pour la récupération des données de l’accélération  angulaire sur X du capteur Xsens DOT, j’ai utilisé une liaison bluetooth additionnel de type Port COM à 115200 bauds avec un programme en Java sur mon PC:

 

Vous pouvez constater sur la vidéo ci-dessous que le résultat est quand même assez impressionnant, la rotation de ma main déclenche bien le déplacement du point rouge sur le smartphone et l’envoie au PC de l’information Gauche/Droite/Centre pour faire réaliser le même déplacement au point vert.

Il y a un délais bien sur entre la modification d’orientation et le déplacement du point. L’algorithme doit être améliorer pour diminuer ce délais.

7/ Nouvelle version des SDK de Xsens

Suite à la conférence d’Avril 2020 de Xsens, j’ai la possibilité de récupérer les données directement depuis le PC. Donc la nouvelle version doit être directement développée sur l’ordinateur pour récupérer les données via le protocole Bluetooth BLE.

Pour simplifier le développement sur Windows, j’ai développé le code en C#. En effet, mes anciens développement avec le bluetooth m’ont montré que ce langage est le plus proche du système d’exploitation sur windows; aucune surprise le langage C# appartient à Microsoft. Du coup, je pense que les ouvertures/fermetures des canaux de communication bluetooth BLE seront simplifiées par ce langage de programmation.

Mon conseil est d’en premier lieu de travailler à partir du document « Xsens DOT BLE Services Specifications » proposé en téléchargement par Xsens sur son site internet. Ce document indique bien une évolution dans l’accès à certaines données envoyés par la nouvelle version (1.3) des Xsens. Personnellement, je vais continuer à utiliser la version 1.0.0 car moins de données = plus simple à interpréter.

Nota: attention au format big-endiant/little-endian des données, j’ai passé un peu de temps en lisant les octets dans le mauvais ordre.
Ce n’est pas encore standardisé, heureusement la documentation indique « All the big-endian members will be changed to little-endian in the next firmware release ».

Le développement a du être mis en stand-by pour cause de projet en parallèle, mais les premiers résultats sont encourageant. Le standard Bluetooth BLE est bien accepté par le xSens DOT comme montre la vidéo suivante qui affiche les accélérations du composant sur un seul axe.

Démonstration de la liaison bleutooth BLE du Xsens avec un développement C# sur un PC Windows 10 Pro version 18362 (Indiquer ma version n’est pas anodin pour le développement bluetooth BLE).

Publié dans Développement | Laisser un commentaire

git sourcesup

https://sourcesup.renater.fr/account/
Mettre un mot de passe du compte unix
Vérifier le mot de passe: https://sourcesup.renater.fr/account/change_pw.php

Trouver l’URL
URL : https://pierre.jean@git.renater.fr/authscm/pierre.jean/git/rearm/rearm.git cf copie d’écran en dessous pour le trouver
login UNIX pierre.jean
le BON MDP de SOurcesup

Ouvrir GitHub Desktop, faire clone a repository du smart https
https://pierre.jean@git.renater.fr/authscm/pierre.jean/git/rearm/rearm.git

—–
Ne fonctionne plus ?

Commande
git init

git clone ssh://git@git.renater.fr:2222/nom_projet.git

git clone https://pierre.jean@git.renater.fr/authscm/pierre.jean/git/rearm/rearm.git

Ouvre fenêtre authentification pour cloner sauf…

git config –global user.email « pierre.jean@mines-ales.fr »
git config –global user.name « pierre.jean »
git add rearm
git commit -m « Message de validation »

Publié dans Développement | Laisser un commentaire

Taiga Docker surprises

 

Pour une première étape avec Docker, j’ai essayé d’installer le logiciel taiga via cet outil de container. La solution la plus classique serait de prendre une image ubuntu et de suivre l’installation de docker (Setup development installation taiga).

Sauf qu’après avoir suivi une formation de Docker, j’ai compris que l’intérêt de Docker ou du moins un intéret est dans les micro service soit d’avoir 5 containers au lieu d’un seul.


NOTE: Vous avez un problème pour impoter votre projet taiga dans taiga (par exemple après une mise à jours) ?

Taiga contient un utilitaire qui se trouve dans le cotnaineur taiga-back et qui permet de faire l’importation suivant cette commande:

/usr/bin/python3 manage.py load_dump dump.json p.jean@mines-ales.fr

 

 

Taiga et Docker

Taiga est un logiciel de gestion de projet agile de type assez classique avec kanban et spring intégré. Ce que j’aime dans Taiga en plus qu’il soit open source est que l’on peut activer ou non les outils agile, par exemple commencé avec un simple kanban et ensuite rajouter des sprint et/ou un wiki et/ou un gestionnaire de bug.

Taiga n’a pas de version officielle de Docker. Plusieurs images sont disponibles mais j’avoue que parfois les personnes qui ont fait les images avaient des idées très précises de leur utilisation qui ne m’allait par.

Dans ma solution je souhaite que Docker puisse gérer les cinq containers avec l’avantage de pouvoir renforcer un container ou le remplacer au besoin :

  • taiga-db database postgreSQL
  • taiga-front pour la partie front web de Taiga
  • taiga-back pour la partie backoffice de Taiga
  • taiga-rabbit pour le gestionnaire de message dans Taiga
  • taga-events pour l’envoie des notifications dans Taiga via le navigateur
  • taiga-proxy pour le serveur front nginx dispatchant les requêtes.

L’image de docker de base

Je pars donc d’une image existante de docker. En fait, j’en essaye plusieurs avant de trouver une image qui correspond à ce que je souhaite soit avec une base de données et avec la partie notifications/messages.

La version suivante : https://github.com/docker-taiga/taiga semble être un bon compromis. Je télécharge donc le dépot github et je fais une installation sans problème sur un serveur linux de test.

Hors, cette installation ne fonctionne qu’une seule fois. Je n’arrive pas en relançant à récupérer le fonctionnement de mon serveur taiga. Après plusieurs essaies et avec l’obligation de devoir intégrer mes propres développements dans Taiga, je suis donc contraint de prépare une installation à partir du fichier docker-compose.yml.

 

Docker-taiga-pje

Pourquoi faire une version de taiga docker personnelles:

  • Je souhaite intégrer 1 fichier et une bibliothèque python en plus.
  • Je souhaite débugger avec un outil curl dans taiga-back et taiga-proxy
  • Je souhaite que le déploiement se fasse tout seul avec le minimum d’intervention de ma part
  • Le container taiga-back contient un serveur web nginx qui fait double emploie pour moi avec le serveur taiga-proxy en frontal
  • Monter en compétence avec Docker avec un exemple et des contraintes réelles
  • Docker sur Windows 10 avec tout les désavantages que l’on y trouve (et il y en a Docker est fait pour Linux et cela se voit)

La première étape que je vais faire est de créer un dossier pour le taiga-proxy et modifier le code de nginx.conf et nginx_ssl.conf pour que le nginx de ce container aille chercher le http://back:8000/. Cela suppose aussi la modificaiton du docker-compose.yml pour qu’il prenne en charge cette nouvelle image appelée taiga-proxy-pje.

Puis je faire la même modification pour le taiga-back pour qu’il prenne en charge de nouveau modules python et modifier le script de démarrage pour ne pas charger le serveur nginx. J’en profiterai pour que le port 8000 de ce container soit accessible pour faire le débogage avec curl installé dans ce container.

 

Etape 1 création de l’image taiga-proxy-pje

Téléchargement des fichiers du dépot git-hub depuis https://github.com/docker-taiga/proxy

 

Version initiale du fichier nginx.conf

server {
	server_name $TAIGA_HOST;
	listen 80;
	location ^~ /events {
		proxy_pass http://$EVENTS_HOST:8888/;
		proxy_http_version 1.1;
		proxy_set_header Upgrade $http_upgrade;
		proxy_set_header Connection "upgrade";
		proxy_connect_timeout 7d;
		proxy_send_timeout 7d;
		proxy_read_timeout 7d;
	}
	location ^~ /api {
		include proxy_params;
		proxy_pass http://$TAIGA_BACK_HOST;
	}
	location ^~ /admin {
		include proxy_params;
		proxy_pass http://$TAIGA_BACK_HOST;
	}
	location ^~ /static {
		include proxy_params;
		proxy_pass http://$TAIGA_BACK_HOST;
	}
	location ^~ /media {
		include proxy_params;
		proxy_pass http://$TAIGA_BACK_HOST;
	}
	location / {
		include proxy_params;
		proxy_pass http://$TAIGA_FRONT_HOST;
	}
}

Version modifiée du fichier nginx.conf

server {
server_name $TAIGA_HOST;
listen 80;
location ^~ /events {
proxy_pass http://$EVENTS_HOST:8888/;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection « upgrade »;
proxy_connect_timeout 7d;
proxy_send_timeout 7d;
proxy_read_timeout 7d;
}
location ^~ /api {
include proxy_params;
proxy_pass http://$TAIGA_BACK_HOST:8000;
}
location ^~ /admin {
include proxy_params;
proxy_pass http://$TAIGA_BACK_HOST;
}
location ^~ /static {
include proxy_params;
proxy_pass http://$TAIGA_BACK_HOST;
}
location ^~ /media {
include proxy_params;
proxy_pass http://$TAIGA_BACK_HOST;
}
location / {
include proxy_params;
proxy_pass http://$TAIGA_FRONT_HOST;
}
}

Maintenant dans le dossier taiga-pje/proxy en ligne de commande pour construire l’image taiga-proxy-pje :

docker build -t taiga-proxy-pje .

Il faut ensuite modifier le fichier docker-compose.yml pour ne plus appeler l’image taiga-proxy mais l’image taiga-proxy-pje, donc après avoir téléchargé tous les fichiers du dossier taiga via git

git clone –depth=1 -b latest https://github.com/docker-taiga/taiga.git

Nous obtenons le dossier suivant:

Nous pouvons donc ensuite modifier le fichier docker-compose.yml:

version: ‘3’

services:
back:
image: taiga-back
container_name: taiga-back
restart: unless-stopped
depends_on:
– db
– events
networks:
– default
volumes:
– ./data/media:/taiga-media
– ./conf/back:/taiga-conf
env_file:
– variables.env

front:
image: dockertaiga/front
container_name: taiga-front
restart: unless-stopped
networks:
– default
volumes:
– ./conf/front:/taiga-conf
env_file:
– variables.env

db:
image: postgres:11-alpine
container_name: taiga-db
restart: unless-stopped
networks:
– default
env_file:
– variables.env
volumes:
– ./data/db:/var/lib/postgresql/data

rabbit:
image: dockertaiga/rabbit
container_name: taiga-rabbit
restart: unless-stopped
networks:
– default
env_file:
– variables.env

events:
image: dockertaiga/events
container_name: taiga-events
restart: unless-stopped
depends_on:
– rabbit
networks:
– default
env_file:
– variables.env

proxy:
image: taiga-proxy-pje
container_name: taiga-proxy
restart: unless-stopped
depends_on:
– back
– front
– events
networks:
– default
ports:
– 80:80
– 443:443
volumes:
#- ./cert:/taiga-cert
– ./conf/proxy:/taiga-conf
env_file:
– variables.env

networks:
default:

 

Pour fabriquer l’ensemble des containers en allant chercher les images, la magie de docker est appeler avec

cd taiga
docker-compose.exe up -d

Pour mémoire, le dossier taiga/ contient le docker-compose.yml qui va faire l’assemblage des images et le dossier proxy contient l’image spéciale docker-proxy-pje.

Rapidement, vous allez faire un fichier go.bat avec:

cd proxy
docker build -t taiga-proxy-pje .
cd ..
cd taiga
docker-compose.exe up -d
cd ..

 

et un purge.bat qui fait plusieurs actions: retire les fichiers indiquant que ce démarrage n’est pas la version initiale, arrête l’option redémarrage des container pour pouvoir les arrêter :

  • retire les fichiers .initial_setup.lock qui indiquent que la configuration a déjà été faite (cf processus de création des fichiers conf ci-dessous)
  • mettre à jours le critères restart à no pour me permettre d’arrêter les containers car sinon docker les redémarre automatiquement, vous pouvez aussi faire docker update –restart=np $(docker ps -q) pour empecher tous les containers en fonctionnement de redémarrer
  • effacer les containeurs
  • effacer les images
  • effacer les volumes non utilisé par aucun container, attention cela pourrait retirer aussi d’autres volumes qui ne serait pas lié à des containers
rm taiga/conf/back/.initial_setup.lock
rm taiga/conf/front/.initial_setup.lock
rm taiga/conf/proxy/.initial_setup.lock
docker update –restart=no $(docker ps -a -q –filter « name=taiga-proxy » –filter « name=taiga-events » –filter « name=taiga-front » –filter « name=taiga-rabbit » –filter « name=taiga-db »)
docker rm taiga-proxy taiga-back taiga-events taiga-front taiga-rabbit taiga-db
docker rmi taiga-proxy-pje dockertaiga/front dockertaiga/events dockertaiga/rabbit dockertaiga/back
docker volume prune –force

Attention c’est assez violent de retirer tous les volumes non utilisé. Dans mon cas je n’avais que les containers et images liés à taiga.

Processus de créations des fichiers

J’ai eu beaucoup de problème pour comprendre qui fabrique les fichiers dans le dossier taiga/conf. En effet, au premier démarrage des containers taiga-back, taiga-proxy, taiga-front, le script appelé par le RUN (habituellement start.sh) de chaque Dockerfile va créer les dossiers et fichiers de la configuraton pour qu’au redémarrage du container, ces fichiers soient utilisés au lieu de les recréer à chaque fois. Le problème est de créer un processus complet de fabrication et non pas de bricoler dans les fichiers de taiga/conf/. On peut modifier ces fichiers pour tester quelqus réglages de nginx par exemple mais il faut bien qu’à la fin on ai la totalité du processus from scratch

Enfin, j’ai un taiga proxy qui appelle sur le port 8000, le serveur django. Maintenant, il faut configurer le taiga-back pour ne pas utiliser le nginx inclus mais directement le django

taiga-back-pje

Création du dossier back et modification du fichier go.sh

cd proxy
docker build -t taiga-proxy-pje .
cd ..
cd back
docker build -t taiga-back-pje .
cd ..

cd taiga
docker-compose.exe up -d
cd ..

 

et purge.bat:

rm taiga/conf/back/.initial_setup.lock
rm taiga/conf/front/.initial_setup.lock
rm taiga/conf/proxy/.initial_setup.lock
docker update –restart=no $(docker ps -a -q –filter « name=taiga-proxy » –filter « name=taiga-events » –filter « name=taiga-front » –filter « name=taiga-rabbit » –filter « name=taiga-db »)
docker rm taiga-proxy taiga-back taiga-events taiga-front taiga-rabbit taiga-db
docker rmi taiga-proxy-pje dockertaiga/front dockertaiga/events dockertaiga/rabbit taiga-back-pje
docker volume prune –force

 

Dans notre dossier back, nous allons trouver:

d—– 11/06/2019 11:04 users <— Le dossier contenant le nouveau fichier python pour l’OTP
-a—- 13/06/2019 18:43 1225 config.py <— Le fichier de configuration de taiga back
-a—- 08/06/2019 14:52 1956 Dockerfile <— Le fichier Dockerfile où le travail est le plus important
-a—- 02/06/2019 17:26 1466 Dockerfile.v0 <— Fichier Dockerfile initial, pour voir entre Linux et Windows
-a—- 08/06/2019 14:17 157 ntpd.conf <— Le container n’a pas accès à l’heure, cf plus bas
-a—- 13/02/2019 10:26 74 README.md <— Le fichier README de github
-a—- 10/06/2019 20:05 2015 start.sh <— Le nouveau fichier start.sh qui va bien changer

Il faut avec le terminal créer une nouvelle image docker-back que l’on va appeler docker-back-pje.

docker build -t taiga-back-pje .

Cette commande fabrique une nouvelle image de taiga-back. Sauf que sur windows, j’ai une erreur :

WARNING: Ignoring APKINDEX.b89edf6e.tar.gz: No such file or directory
WARNING: Ignoring APKINDEX.737f7e01.tar.gz: No such file or directory

Cette erreur vient d’un problème de dossier cache des packages d’alpine.

La solution est de modifier le dockerfile pour détruire ce cache et d’ajouter le package ca-certificates.
Je rajoute aussi le package « jq » pour avoir un outil d’affichage des données json lisible.

FROM alpine:latestENV TAIGA_HOST=taiga.lan \
TAIGA_SECRET=secret \
TAIGA_SCHEME=http \
POSTGRES_HOST=db \
POSTGRES_DB=taiga \
POSTGRES_USER=postgres \
POSTGRES_PASSWORD=password \
RABBIT_HOST=rabbit \
RABBIT_PORT=5672 \
RABBIT_USER=taiga \
RABBIT_PASSWORD=password \
RABBIT_VHOST=taiga \
STARTUP_TIMEOUT=15sWORKDIR /srv/taigaRUN rm -rf /var/cache/apk/* && rm -rf /tmp/* \
&& apk –no-cache add python3 gettext postgresql-dev libxslt-dev libxml2-dev libjpeg-turbo-dev zeromq-dev libffi-dev nginx \
&& apk add –no-cache –virtual .build-dependencies musl-dev python3-dev linux-headers git zlib-dev libjpeg-turbo-dev gcc ca-certificates jq \
&& mkdir logs \
&& git clone –depth=1 -b stable https://github.com/taigaio/taiga-back.git back && cd back \
&& sed -e ‘s/cryptography==.*/cryptography==2.3.1/’ -i requirements.txt \
&& pip3 install –upgrade pip \
&& pip3 install -r requirements.txt \
&& rm -rf /root/.cache \
&& apk del .build-dependencies \
&& rm /srv/taiga/back/settings/local.py.example \
&& rm /etc/nginx/conf.d/default.conf

EXPOSE 80

WORKDIR /srv/taiga/back

COPY config.py /tmp/taiga-conf/
COPY nginx.conf /etc/nginx/conf.d/
COPY start.sh /

VOLUME [« /taiga-conf », « /taiga-media »]

CMD [« /start.sh »]

Ok cela fabrique l’image, je peux modifier le fichier docker-compose.yml et recréer l’ensemble des images manquantes et des containers associés avec le script go.sh

version: ‘3’

services:
back:
image: taiga-back-pje
container_name: taiga-back
restart: unless-stopped
depends_on:
– db
– events
networks:
– default
volumes:
– ./data/media:/taiga-media
– ./conf/back:/taiga-conf
env_file:
– variables.env

front:
image: dockertaiga/front
container_name: taiga-front
restart: unless-stopped
networks:
– default
volumes:
– ./conf/front:/taiga-conf
env_file:
– variables.env

db:
image: postgres:11-alpine
container_name: taiga-db
restart: unless-stopped
networks:
– default
env_file:
– variables.env
volumes:
– ./data/db:/var/lib/postgresql/data

rabbit:
image: dockertaiga/rabbit
container_name: taiga-rabbit
restart: unless-stopped
networks:
– default
env_file:
– variables.env

events:
image: dockertaiga/events
container_name: taiga-events
restart: unless-stopped
depends_on:
– rabbit
networks:
– default
env_file:
– variables.env

proxy:
image: taiga-proxy-pje
container_name: taiga-proxy
restart: unless-stopped
depends_on:
– back
– front
– events
networks:
– default
ports:
– 80:80
– 443:443
volumes:
#- ./cert:/taiga-cert
– ./conf/proxy:/taiga-conf
env_file:
– variables.env

networks:
default:

Sauf que après un petit tour dans le container taiga-back fabriqué à partir de mon image taiga-back-pje

docker exec -it taiga-back sh

La date est complètement fausse sur Windows

En fait, docker windows ne peut accéder (avec la version que j’avais en mars 2019) à l’horloge système.
Il n’y a pas de problème sous Linux.

Comme j’ai besoins de cette date à jour pour la suite du projet. Je dois injecter un serveur de temps openntpd et le configurer dans l’image docker-back-pje

Nouveaux modifications du fichier Dockerfile

FROM alpine:latestENV TAIGA_HOST=taiga.lan \
TAIGA_SECRET=secret \
TAIGA_SCHEME=http \
POSTGRES_HOST=db \
POSTGRES_DB=taiga \
POSTGRES_USER=postgres \
POSTGRES_PASSWORD=password \
RABBIT_HOST=rabbit \
RABBIT_PORT=5672 \
RABBIT_USER=taiga \
RABBIT_PASSWORD=password \
RABBIT_VHOST=taiga \
STARTUP_TIMEOUT=15sWORKDIR /srv/taigaRUN rm -rf /var/cache/apk/* && rm -rf /tmp/* \
&& apk –no-cache add python3 gettext postgresql-dev libxslt-dev libxml2-dev libjpeg-turbo-dev zeromq-dev libffi-dev nginx \
&& apk add –no-cache –virtual .build-dependencies musl-dev python3-dev linux-headers git zlib-dev libjpeg-turbo-dev gcc ca-certificates jq openntpd \
&& mkdir logs \
&& cp /usr/share/zoneinfo/Europe/Paris /etc/localtime && echo « Europe/Paris » > /etc/timezone && renice -n-8 $(pidof ntpd -s) \
&& git clone –depth=1 -b stable https://github.com/taigaio/taiga-back.git back && cd back \
&& sed -e ‘s/cryptography==.*/cryptography==2.3.1/’ -i requirements.txt \
&& pip3 install –upgrade pip \
&& pip3 install -r requirements.txt \
&& rm -rf /root/.cache \
&& apk del .build-dependencies tzdata \
&& rm /srv/taiga/back/settings/local.py.example \
&& rm /etc/nginx/conf.d/default.conf

EXPOSE 80

WORKDIR /srv/taiga/back

COPY ntpd.conf /etc/ntpd.conf
COPY config.py /tmp/taiga-conf/
COPY nginx.conf /etc/nginx/conf.d/
COPY start.sh /

VOLUME [« /taiga-conf », « /taiga-media »]

CMD [« /start.sh »]

On note qu’il y a une injection de la timezone dans le fichier /etc/timezone pour indiquer le fuseau horaire

Bien sur le fichier ntpd.conf sur le disque dur a ces informations

# See ntpd.conf(5) and /etc/examples/ntpd.conf
listen on *server time1.google.com
server time2.google.com
server time3.google.com
server time4.google.com

On peut indiquer d’autres serveurs de temps dans le cas d’une structure qui aurait une politique locale des serveurs de temps

Je suis toujours dessus pour améliorer le processus…

Publié dans Développement | Laisser un commentaire

Accès manager-gui via Tomcat 8.5 dans Docker

Suite à l’installation de Tomcat 8.5 dans docker, je n’ai pas trouvé simplement comment accéder à l’interface de déploiement web dans Tomcat.

Il faut donc modifier les fichiers suivants:

/usr/local/tomcat/conf/tomcat-users.xml:

<role rolename="manager-gui"/>
<role rolename="manager-script"/>
<user username="admin" password="password" roles="manager-gui,manager-script" />

Puis aller dans les réglages de l’application manager dans /usr/local/tomcat/webapps/manager/META-INF/context.xml et modifier le tag suivant :

 <Valve className="org.apache.catalina.valves.RemoteAddrValve"
allow="127\.\d+\.\d+\.\d+|::1|0:0:0:0:0:0:0:1" />

Par ceci:

 <Valve className="org.apache.catalina.valves.RemoteAddrValve"
allow="\d+\.\d+\.\d+.\d+|127\.\d+\.\d+\.\d+|::1|0:0:0:0:0:0:0:1" />

Merci à cet article :

https://stackoverflow.com/questions/42692206/docker-tomcat-users-configuration-not-working

 

 

 

 

 

Publié dans Développement | Laisser un commentaire

gvim et vimrc

Habituellement je n’utilise que la ligne suivante dans mon fichier vimrc qui gère la configuration par défaut de mon gvim/vim :

colorscheme slate

Juste le changement du thème et donc des couleurs par défaut de Gvim en choisissant un thème prédéfini.

J’avais besoin de disposer d’un Gvim ouvert au centre de mon écran de taille plutôt réduite déjà en mode édition avec un fichier vide par défaut. Du coup, j’ai installé le plugin wimproved.vim. Ce plugin a installer simplement, le fichier wimproved32.dll dans le dossier principal de vim, dans le dossier autoload le fichier autoload/wimproved.vim et dans le dossier plugin le fichier plugin/wimproved.vim.

Ensuite il faut configurer le fichier vimrc :

" Simplifier l'interface de gvim en retirant le menu et les icones
autocmd GUIEnter * silent! WToggleClean
" Centrer gvim avec une taille de 30% de l'écran
autocmd GUIEnter * silent! WCenter 30
" Degré de transparence de l'interface sur 255 niveau
autocmd GUIEnter * silent! WSetAlpha 220
" Couleur du thème
colorscheme slate

" test si c'est l'édition d'un nouveau fichier ou d'un fichier existant
" ces réglages ne sont appliqués qu'au nouveau fichier pas aux fichiers en éditon 
if argc()==0

  " cache les symboles ~ qui indiquent des lignes non existente
  hi NonText guifg=bg
  " fait une insertion vide par défaut pour retirer le message d'introduction 
  normal i 
  " mode insertion au lieu d'être mode commande comme habituellement
  start
endif


 

Vi / VIM / Gvim sont des outils très pratiques car disponiblent sur toutes les plateformes et les systèmes d’exploitations. Ils gèrent un nombre important type de format et ouvrent même des fichiers de tailles énormes sans sourciller. Je sais que l’apprentissage sur cet outil est compliqué (mode commande <-> mode édition) mais les manipulations de types expressions régulières et les plugins additionnels en font un outil extraordinaire.

Efface les lignes avec le mot profile quelque part:

:g/profile/d

Efface les lignes ne contenant par le mot profile quelque part:

:g!/profile/d

 

 

Publié dans Développement | Laisser un commentaire

Résultat du sondage de Stackoverflow 2017 et Infographie de Chooseyourboss 2018

Le sondage 2017 du site web de support informatique stackoverflow vient de sortir. Le sondage est très/trop complet notamment sur des questions hors du domaine du développement (le développeur a t’il des enfants par exemple). Vous pouvez le trouver à cette URL.

Je sors quelques points que je trouve intéressant et donc ce n’est que mon regard personnel sur ce sondage, chacun est libre d’en sortir ses propres impressions.

Et blog de Choose Your Boss a ajouté une infographie pour 2018

 

 

Comment se définit le développeur:

Finalement on peut dire que les sondés sont globalement des développeurs qui font un peu de tout en Front/Back/Full, finalement c’est le « Desktop or entreprise applications » qui montre bien que ce type de développement est assez faible sur ce site. Peut être que les développeurs de ce genre d’applications sont expérimentés et n’ont plus besoin de poser des questions.

 

La bataille des IDEs:

Le Visual Studio payant et gratuit semble enfoncé les autres, le trio des éditeurs Sublime Text/Vim/Notepad++ semble être très utilisé au final, le reste est très classique au final.

Les langages des développeurs:

Beaucoup de développement web en Front, donc JS+HTML+CSS sontles premier. On trouve les inaltérables SQL/Shell en plus. La tendance reste Java/Python/C#/PHP/C++/C.  J’ai indiqué les langages ayant plus de 10%, vous trouverez surement votre langage dans le sondage.

 

Les Framework des développeurs:

Node.js / Angular /react indique bien que le développement des solutions javascript a le vent en poupe. Ce qui est surprenant encore c’est le .Net Core qui est très important, une information que je n’avais pas personnellement.

Base de données utilisées

 

La seconde place de SQL Server est pour moi une surprise, le reste me parait assez classique comme représentation.

Les plateformes cible des développeurs:

Attention, ce n’est pas avec quel OS ils développent, il y a une réponse spécifique sur ce point. On voit bien que le classique c’est Linux/Windows, un peu d’android, de cluster AWS, Mac OS. Rasberry Pi et WordPress sont présentés comme des cibles cela indique bien la force de leur spécificité.

 

Les regroupement  des technologies pour les développeurs:

Très utile cela indique bien les liaisons outils/technologies/plateformes pour comprendre qu’elles sont les compétences liées.

 

 

Publié dans Développement | Laisser un commentaire

Arduino M0 pro et UART additionnel

Dans le cadre d’un développement sur un Arduino M0 Pro, je me retrouve a devoir brancher en protocole UART un module bluetooth et un lecteur RFID tout les deux en UART.

Comme je débute en Arduino, je branche le module bluetooth sur RT( broche 0) /TX (broche 1) de la carte :

 

Donc se pose la question d’avoir une entrée UART sur d’autres broches. J’avoue que je traine sur google et que je trouve enfin la bonne explication pour transformer les broches  10 en TX et 11 en RX.

Vous trouverez sur ce lien toutes les explications chez Adafruit mais pour ceux qui cherchent comme moi, voici le résumé avec le code:

#include "wiring_private.h"

Uart Serial2(&sercom1, 11, 10, SERCOM_RX_PAD_0, UART_TX_PAD_2);

void SERCOM1_Handler()
{
 Serial2.IrqHandler();
}

void setup()
{
  Serial2.begin(9600);
  pinPeripheral(10, PIO_SERCOM);
  pinPeripheral(11, PIO_SERCOM);
}


void loop()
{
 if (Serial2.available()){
   byte byteRead = Serial2.read();
   Serial2.write(byteRead);
   Serial.write( byteRead ); 
 }
}

Et voila, j’avoue que cela m’a permis d’entrer dans des détails du « M0 pro » et de son contrôleur ATSAMD21  mais enfin j’ai compris comment on peut refaire un UART de plus en cas de besoin.

Voila le montage final avec UART sur PIN 0 et 1, SDA & SCL branché et enfin le nouveau UART PIN 10 et PIN 11

Publié dans Développement | Laisser un commentaire

Formation python Quatrième partie

 EXERCICE ONZE

Manipulons quelques fonction de la bibliothèque numpy:

import numpy as np
donneesX = np.array([[1,2,3,15,18] , [18,22,4,15,15]])
print ( donneesX.shape )

 

Fabrication d’un tableau de séries de données

import numpy as np
temperature = np.arange(25,44.5,0.5)
print( temperature )

print( temperature.mean() )
print( np.mean( temperature ) )

print( np.min( temperature ) )
print( np.max( temperature ) )
print( np.median( temperature ) )
print( np.std( temperature ) )

 

Manipulation de matrice par l’appel de fonction sur chaque élément:

import numpy as np
temperature = np.arange(25,44.5,0.5)

def toKelvin(x):
 return x + 273.15

print( toKelvin( temperature ) )

 

Manipulation des tableaux par réorganisation des lignes et des colonnes

a = np.arange(6)
print( a )
a = np.arange(6).reshape(2,3)
print( a )

Itération sur chaque élément du tableau:

a =np.array([[1,2],[3,4],[5,6]])
for (x,y), valeur in np.ndenumerate(a):
   print( valeur )

Plus compliqué en indiquant que les valeurs pour les indices paires:

a =np.array([[1,2],[3,4],[5,6]])
for (x,y), valeur in np.ndenumerate(a):
   if x % 2 == 0 
      print( valeur )

Ou le second éléments de chaque sous-tableau:

a =np.array([[1,2],[3,4],[5,6]])
for (x,y), valeur in np.ndenumerate(a):
   if y == 1 
      print( valeur )

Attention imaginons ce type de situations et que nous voulons le dernier élément

a =np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
for (x,y), valeur in np.ndenumerate(a):
   if y == 1 
      print( valeur )

Il faudrait alors utiliser

a =np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
[ soustableau[ -1 ] for soustableau in a]

Mais en fait il faudrait écrire plutôt

a =np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
for valeur in ( [ soustableau[ -1 ] for soustableau in a] ):
  print( valeur )

 

Publié dans EuroMov | Laisser un commentaire

Formation python Troisème partie

 EXERCICE NEUF

Demander une information depuis la ligne de commande, pour filtrer les informations et ne garder que celle dont le numero_ligne est supérieur au numero_ligne_initial indiqué par l’utilisateur.

Pour demander une variable, voici la commande

numero_ligne_initial = input('Numéro de ligne initial: ')
numero_ligne_initial = int(numero_ligne_initial)

Normalement votre console va contenir ce message, avec le curseur pour attendre que vous indiquiez à partir de quel ligne on va traiter l’information

Numéro de ligne initial: _

 

Filtrer les informations à partir d’un numéro de ligne ->

 

 

 


HUITIEME TRUC

Les bibliothèques additionnelles sont très importantes dans python. Par défaut, python ne charge pas toutes les bibliothèques car cela prendrais trop de temps, cela chargerais en mémoire trop d’informations et même il y a risque d’incompatibilités entre certaines bibliothèques. Donc on charge que ce que l’on a besoin et on les importes individuellement.

Par exemple pour faire un graphisme, la bibliothèque que je propose est matplotlib.

Pour l’installer, il faut soit appeler en ligne de commande le logiciel pip par exemple via la commande du système d’exploitation (terminal sous MacOs, cmd sous Windows :

pip install requests

ou on trouve aussi la commande exprimé comme ceci:

python -m pip install <nom de la bibliothèque>

Ce que je conseille sinon c’est ce petit programme python qui exécute pip (qui est développé en python), à exécuté dans l’interpreteur python:

Python 3.6.2 (v3.6.2:5fd33b5, Jul 8 2017, 04:57:36) [MSC v.1900 64 bit (AMD64)]
 on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>import pip
>>>pip.main(['list'])
>>>pip.main(['install','<nom de la bibliothèque>'])

Mais ce qui est vraiment pratique avec PyCharm c’est que l’on peut faire via l’IDE tout cela:

Allez sur le Menu File > Settings…

NOTA: sous Mac Os le menu settings est déplacé dans le menu le plus à gauche portant le nom de l’application soit ici PyCharm > Settings…

Choisissez « Project: <votre projet> » puis « Project Interpreteur » et complètement à droite le bouton « + » puis vous pouvez chercher une bibliothèque (un package en VO) par exemple « matplotlib » pour l’installer.

Une fois l’installation terminé, on peut constater que matplotlib n’a pas été installé tout seul mais des bibliothèques additionnelles ont été aussi installé pour le faire fonctionner:

On peut constater que la bibliothèque numpy qui est très utile pour le calcul scientifique est aussi installé car elle est nécessaire à matplotlib.

 


NEUVIÈME TRUC

 

Pour l’utilisation de matplotlib et numpy pour faire une figure et des calculs, il faut en premier lieu importer les bibliothèques. Pourquoi indiquer dans un programme ce que l’on veut importer précisément, on pourrait penser que python va charger toutes les bibliothèques que l’on a installer, oui mais dans ce cas là on va avoir un long temps de chargement avant que notre programme ne s’exécute.

Pour importer l’objet qui gère dans la bibliothèque matplotlib l’objet qui gère les diagrammes, on peut écrire ceci:

from matplotlib import pyplot

Mais on trouve la version plus abrégé suivante:

import matplotlib.pyplot

Sauf qu’après on se retrouve à devoir faire préfixer toutes les fonctions de cet objet, par exemple ici la fonction figure() par le nom de la bibliothèque + le nom de l’objet:

matplotlib.pyplot.figure()

Donc on peut faire un alias (le mot après as) pour remplacer le préfixe par quelquechose de plus court

import matplotlib.pyplot as plt

et du coup l’appel se fait avec la version écourtée:

plt.figure()

Par exemple pour numpy la bibliothèque de calcul scientifique, son alias est souvent np.

 

Mais revenons à ce que nous avons besoin d’importer pour faire une courbe :

import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D

Voici un petit morceau de programme pour tracer une courbe simple:

donnees = [18,22,4,15,15]
fig = plt.figure()
ax = fig.gca()
ax.plot( donnees , label='parametric curve')
plt.show()

Essayer d’afficher à l’écran cette courbe et modifier les données pour construire un autre exemple.

On peut faire une courbe avec deux dimensions :

donneesX = [1,2,3,15,18]
donneesY = [18,22,4,15,15]
fig = plt.figure()
ax = fig.gca()
ax.plot( donneesX, donneesY , label='parametric curve')
plt.show()

 


 EXERCICE DIX

Cette courbe est le début du vol du planeur enregistré par le GPS d’un smartphone.

Essayons de construire un programme pour l’afficher avec les données du fichier traitement_fichier.txt.

En premier lieu, importer matplotlib et numpy. Ensuite il faut créer trois tableaux pour stocker les informations:

#initialisation des tableaux de données
longitude = []
latitude = []
altitude = []

Puis après avoir passé la première ligne du fichier traitement_fichier.txt qui contient les entête des colonnes. Nous pouvons ajouter les valeurs lu comme str en valeur de type float (nombre à virgule) via ces lignes:

#construction des tableaux de données
latitude.append(float(data[1]))
longitude.append(float(data[2]))
altitude.append(float(data[3]))

Bien sur éviter de lire la colonne data[0] qui contient les timestamps peut utile pour ce diagramme.

A la fin de notre programme après avoir bien construit les 2 tableaux de données voici le code pour afficher le diagramme:

#dessin de la figure
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.plot(longitude, latitude, altitude, label='parametric curve')
plt.show()

A vous de jouer.

Affichage des données longitude, latitude, altitude ->

 

 


DIXIÈME TRUC

 

Si vous ne codez pas, tout cela ne va pas vraiment être utile.

Mettez des commentaires pour expliquer les morceaux du code.

Indiquez clairement ce que fais une variable, numero_ligne ou numeroLigne.

Faites des fichiers intermédiaires pour pouvoir rejouer l’intégralité ou une partie du processus.

Utilisez le déboggage pour tracer l’enchainement du code et l’état des variables.

 

Quatrième partie de la formation ⇒

 

 

Publié dans EuroMov | Laisser un commentaire

Formation python Seconde partie

 CINQUIÈME TRUC

 

Utilisation d’un  IDE (integrated development environment) performant pour gérer plusieurs fichiers pythons ou autre, plusieurs fichiers de données, plusieurs versions, etc.

Il y a de nombreux IDEs python, celui que je recommande actuellement est la version gratuite de PyCharm appelé PyCharm Community Edition; elle est très complète comme version. (Lien personnel pour le TP: téléchargement)

A installer sur votre ordinateur comme habituellement, n’importez pas de « settings » et prenez les réglages par défaut.

Créez un nouveau projet, en fait un dossier qui va contenir vos futurs développements en python. Vous pouvez vérifier que PyCharm va bien utiliser python3.x pour vos développements.

Fermer le « Tip of the Day » et vous avez l’interface de PyCharm devant les yeux:

OK c’est ma version car vous n’avez en fait aucun dossier ni aucun fichiers actuellement. Donc par exemple, faites click droit dans la zone « Fichiers et dossier » dans le menu choisir:

New > Directory

Entrez le nom du dossier par exemple test et copier coller le fichier exercice1.py dedans.

Ouvrez le fichier exercice1.py en double cliquant dessus :

On peut exécuter le fichier exercice1 via le bouton en haut à droite ou le raccourci indiqué en survol de ce bouton. Le résultat de l’exécution sera visible donc dans la fenêtre du bas.

 


EXERCICE QUATRE

Télécharger le fichier de données à cette adresse : traitement_fichier.xls

Copiez le fichier dans PyCharm avec Copier / Coller et profiter pour renommer le fichier en traitement_fichier.txt :

Nous allons manipuler le fichier de données traitement_fichier.txt pour extraire de l’information, vous pouvez l’ouvrir dans PyCharm pour voir sa composition:

timestamp;latitude;longitude;altitude
1491486784141;43.64093363956815;3.851249759920415;109.30910031218662
1491486785141;43.64089947397977;3.8512505542990336;111.87747544303649
1491486786141;43.64088583922287;3.8512393755398326;113.0741231549388

...

Il s’agit des données en provenance d’un vol de planeur enregistré avec le GPS d’un smartphone.

On va donc dans le dossier test avoir le premier fichier exercice1.py, le fichier de données traitement_fichier.txt et on va ajouter un nouveau fichier, manipulation_fichier.py :

On va accéder au fichier pour afficher le contenu avec ces commandes:

with open("traitement_fichier.txt", "r") as fichier:
    contenu = fichier.readlines()
    print( contenu )
fichier.close()

Voici les données obtenus :

['timestamp;latitude;longitude;altitude\n', '1491486784141;43.64093363956815;3.851249759920415;109.30910031218662\n',

Nous devons en premier lieu traiter le problème du retour à la ligne « \n » en le retirant pour chaque ligne.

Voici le code pour traiter ligne à ligne la variable contenu en retirant à chaque fois le retour à la ligne:

with open("traitement_fichier.txt", "r") as fichier:
    contenu = fichier.readlines()
    for ligne in contenu:
        ligne = ligne.rstrip("\n")
        print(ligne)
fichier.close()

Vous pouvez voir que l’indentation du code en python remplace les end du Matlab. Ils ne sont donc pas optionnel, ils donnent un sens à ce qui est dans la boucle et ce qui n’est pas dans la boucle.

% Exemple Matlab valable mais non indenté
for c = 1:10
for r = 1:20
H(r,c) = 1/(r+c-1);
end
end

Nous allons ensuite nous concentrer sur le timestamp et l’altitude en extrayant que ces 2 colonnes:

with open("traitement_fichier.txt", "r") as fichier:
    contenu = fichier.readlines()
    for ligne in contenu:
        ligne = ligne.rstrip("\n")
        data = ligne.split(";")
        # ici afficher les colonnes 0 et 3 
fichier.close()

OK à vous , il faut extraire uniquement les altitudes qui ont été enregistré après le timestamp « 1491486791998 »

 

RÉPONSE A L’EXERCICE 4

Afficher la réponse pour avoir les altitudes ->

 


SIXIÈME TRUC

 

Test de quelques commandes dans l’interpréteur intégré de PyCharm. Nous avons avec PyCharme la possibilité de lancer des programmes dans l’IDE mais pour tester quelques lignes de commandes, l’IDLE est très pratique. Heureusement, nous pouvons avoir l’interpréteur de  commande dans PyCharm via le Menu Tools > Python Console …

Vous aurez ainsi la possibilité de tester quelques commandes avant de les intégrer dans votre fichier de commandes.


 EXERCICE CINQ

 

Afficher au format CSV les données suivantes pour les timestamps supérieurs à « 1491486791998 » avec un numéro de ligne incrémenté à chaque ligne:

1,1491486784141,109.30910031218662
2,1491486785141,111.87747544303649
3,1491486786141,113.0741231549388
4,1491486787141,112.96381095914386
5,1491486788142,113.037303562919
6,1491486789142,116.63811281139428
7,1491486790142,117.30185665137451

Nous allons donc créer une variable numero_ligne et l’incrémenté à chaque lecture de ligne :

numero_ligne = 0

Ensuite nous allons afficher les informations que nous voulons avec ce genre de ligne qui concatène les informations avec des « , »

print( numero_ligne + "," + data[0] + "," + data[3]  )

Mais malheureusement ou pas si vous essayez cette ligne que vous pouvez tester dans l’IDLE de Python ou en ouvrant l’interpréteur dans PyCharm comme vu précédemment.

numero_ligne = 0
print( numero_ligne + ","  )

Vous avez une erreur de type numero_ligne est de type entier (int en VO) et python ne veut pas prendre la responsabilité de le convertir en chaine de caractère (str en VO).

Essayez donc ceci encore une fois dans l’interpreteur:

unTexte = "1491486791998"
unNombre = int( unTexte )
unNouveauTexte = str( unNombre )

On doit donc convertir notre numero_ligne en str pour l’utiliser pour l’affichage.

En fait depuis le début on manipule des textes et non pas des nombres. Ce qui parfois va entrainer quelques problèmes de conversion que l’on verra plus tard.

RÉPONSE A L’EXERCICE 5

Afficher la réponse pour avoir les altitudes avec des numéro de lignes et un affichage en CSV ->

 


EXERCICE SIX

 

Maintenant, pour pouvoir enchainer les futurs traitements sur les données, le plus simple est de sauvegarder notre résultat au lieu de l’afficher à l’écran.

Pour écrire un fichier, on va faire en fin de notre programme comme ceci pour tester la création du fichier:

with open("extraction_fichier.txt", "w") as fichier_sortie:
    fichier_sortie.write( "numero_ligne;timestamp;altitude" )
fichier_sortie.close()

A vous d’intégrer ces modifications pour écrire non plus seulement une ligne d’entête mais toutes les données extraites précédemment dans ce fichier

RÉPONSE A L’EXERCICE 6

Ecrire les données extraites dans un fichier ->

 


SEPTIÈME TRUC

 

Le débugger est le meilleurs outil intégré dans les IDEs quelque soit le langage de programmation. Au lieu de ne disposer des erreurs ou des messages à la fin de l’exécution des programmes, le débuggeur fait exécuter étape par étape le programme.

La différence est similaire entre l’exécution d’une action de football en plein vitesse ou au ralenti:

 

Nous allons donc pour commencer ajouter un point d’arrêt à notre programme puis le faire exécuter ligne par ligne.

Pour bien débuter, nous allons mettre ce point d’arrêt à la première ligne de notre programme; plus tard nous mettrons ce point d’arrêt plus loin dans le programme car ce qui va nous intéresser sera non pas le début mais un endroit spécifique du programme.

C’est similaire avec l’action du but que l’on va décortiquer et non pas tout le début du match.

Placer le point d’arrêt en cliquant à droite du numéro de ligne, normalement un petit point rose indique que le point d’arrêt est actif.
Puis appuyer sur le bouton « Debug » en haut à droite juste à côté du bouton « Run ».

Le programme va démarrer et se mettre en pause sur la ligne avec le point d’arrêt. Pour enchainer ligne par ligne notre programme, nous allons utiliser soit le bouton « Ligne suivante » sur le dessin (Step over en VO) soit pour plus de simplicité la touche Fn+F8 sur MacOs et F6 sous Windows:

Nous pouvons avoir l’état des variables en mémoire soit dans la fenêtre du bas soit dans le code juste à droite de la ligne exécutée. Le mode debugage est très utile pour voir ce qui peut entrainer une erreur dans notre programme et en vérifiant l’enchainement qui est réalisé selon l’état des variables.

Pour retirer le point d’arrêt il faut cliquer de nouveau dessus. Vous pouvez avoir plusieurs points d’arrêt et les options de débogages sont très nombreuses, nous ne rentrerons pas dans les détails pour l’instant.

 


EXERCICE SEPT

Essaye le mode debugage sur votre programme pour vérifier l’enchainement des étapes.

Faites un point d’arrêt en face de l’instruction :

numero_ligne = numero_ligne + 1

Faites un clic droit sur le point d’arrêt et indiquer comme Condition:

numero_ligne == 10

Relancer le debugogage pour vérifier que le point d’arrêt ne se déclenche que quand cette valeur est atteinte.

 


EXERCICE HUIT

Nous voudrions obtenir le fichier de données suivant avec les timestamps qui sont transformé en intervalles de temps entre deux échantillonnages depuis un t zéro à la première valeur acquise par le GPS.

Ancien fichier:

timestamp;latitude;longitude;altitude
1491486784141;43.64093363956815;3.851249759920415;109.30910031218662
1491486785141;43.64089947397977;3.8512505542990336;111.87747544303649
1491486786141;43.64088583922287;3.8512393755398326;113.0741231549388
1491486787141;43.64090016392363;3.851241228679665;112.96381095914386

 

Nouveau fichier avec les intervalles de temps

1,0,109.30910031218662
2,1000,111.87747544303649
3,1000,113.0741231549388
4,1000,112.96381095914386
5,1001,113.037303562919
6,1000,116.63811281139428
7,1000,117.30185665137451
8,1857,117.30387542891553
9,1000,117.57712510977889
10,1000,118.1639542835122
11,1000,118.54163427393473

Calcul des intervalles de temps entre deux acquisitions ->

 

 


Troisième partie de la formation >>>

 

Publié dans EuroMov | Laisser un commentaire