Lecteur de code barre + liste de courses

[Bull_Eye]

Bonjour à tous.

Je vous présente le projet que je suis en train de réaliser et qui pour le moment me donne satisfaction mais pas à 100%. J'y reviendrai plus tard.

Donc comme indiqué dans le titre, voici la façon dont je vais procéder:

Objectif :
Utiliser un scanner de code barre pour scanner les produits lorsqu’ils sont terminés (avant de les jeter) pour ajouter directement l’aliment ou l’objet à la liste de courses dans Google Keep.

Objets nécessaires :
Un RPI (zero-w parce que c'est très compact et que j'en ai un sous la main).
Une carte micro-SD (celle que j'ai fait 16Go)
Un scanner USB. J'ai décidé de prendre le modèle Anl 810 Usb parce qu'il a un port USB et que je l'ai trouvé sur Leboncoin à un prix raisonnable.
Un adaptateur USB type A femelle vers micro-USB type B mâle
[img]https://www.vs-elec.fr/3696-large_defau ... b-male.jpg[/img]

Infos :
Le RPi aura besoin d’une connexion internet en permanence. Il sera donc connecté sur le wifi du domicile.
Le scanner devra être en veille permanente (alimenté en 5V).
On pourrait imaginer avoir un capteur de proximité pour déclencher le scan car actuellement il faut appuyer sur le bouton du scanner.
Je me suis fortement inspiré du projet sur le lien suivant.
https://www.instructables.com/id/USB-Ba ... pberry-Pi/

Programme :
Le programme devra suivre ce cheminement :
- Lancement du programme au démarrage du RPi
- Lecture et traitement du code reçu par le lecteur
- Connexion au site web qui va bien pour récupérer le nom du produit en fonction du code barre (Il faudra probablement utiliser 3 ou 4 sites différents selon l’objet)
- Envoi vers liste de course Google Keep

[Bull_Eye]

Donc pour commencer il va falloir paramétrer le RPi.
Je vais faire en sorte de ne pas avoir à y brancher de clavier ni d'écran et je vais donc faire une configuration dite "Lite"
De toute façon, le RPi fonctionnera en "headless" c'est à dire qu'on aura jamais besoin d'y connecter autre chose que le scanner de code barre.

Donc pour ça j'ai choisi de partir sur la dernière version de Raspbian en Lite disponible sur le lien suivant:
Lien vers Raspbian

J’ai pris le fichier zip.
Ensuite il faut extraire le contenu du zip et vous aurez un fichier ".img"

J'ai formaté la carte micro SD avec le logiciel SD Card Formatter.
Logiciel : Lien vers SD Card Formatter
Procédure : Lien vers procédure SD Card Formatter

Ensuite j'ai utilisé le logiciel Win32DiskImager pour copier le fichier ".img" dans la carte SD.
Logiciel : Lien vers Win32DiskImager
Procédure : Lien vers procédure Win32DiskImager

Pour pouvoir configurer le RPi sans clavier ni écran, il faut activer la fonctionnalité SSH.
Procédure : Lien vers procédure SSH
En réalité il faut juste créer un fichier nommé « ssh » (sans extension) à la racine de votre carte micro SD

Ensuite il faut que le RPi puisse se connecter à votre wifi.
Procédure : Lien vers procédure Wifi
En réalité il faut juste créer un fichier "wpa_supplicant.conf" avec le contenu suivant:

Code : Tout sélectionner

country=France
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
 
network={
	ssid="le_nom_de_votre_routeur_wifi"
	psk="votre_mot_de_passe"
	proto=RSN
	key_mgmt=WPA-PSK
	pairwise=CCMP
	auth_alg=OPEN
}

J'ai utilisé Notepad++ pour éditer le fichier
Logiciel : Lien vers Notepad++

Il ne reste plus qu'à insérer la carte micro SD dans le Raspberry Pi et à l'alimenter.
Les LEDS verte et rouge vont clignoter puis au bout de quelques minutes, le Raspberry Pi devrait se connecter à votre WIFI

Lorsqu’il est connecté à votre wifi, il faudra utiliser un utilitaire pour connaitre son adresse IP. Perso j’utilise l’application Fing sur Android. ça implique évidemment que votre Smartphone soit connecté à votre wifi.
Application : Lien vers application Fing

Ensuite il faut utiliser le logiciel Putty pour se connecter en SSH au RPi. Je pense qu'il est possible d'utiliser d'autres logiciels donc n'hésitez pas à fouiller un peu sur le forum.
Logiciel : Lien vers Putty
Procédure : Lien vers procédure Putty
Une fenêtre de faille de sécurité va s’afficher mais pas besoin d’en tenir compte. Appuyez sur « oui »
Login : pi
Password : raspberry

Ensuite il faut mettre à jour votre RPi en envoyant les commandes suivantes (pour faire un coller, faire un clic droit):

Code : Tout sélectionner

sudo apt-get update

Puis lorsque l’update sera terminé,

Code : Tout sélectionner

sudo apt-get upgrade

Il faudra valider par un « y » à un moment donné

Ensuite il faut modifier le nom de votre RPi et le mot de passe

Code : Tout sélectionner

sudo raspi-config

Aller dans Network Options\Hostname
Entrer le nom que vous souhaitez,
Ensuite aller dans Change User Password
Valider puis redémarrer le RPi

[Bull_Eye]

La suite:

Il va falloir installer Samba pour pouvoir transférer facilement les fichiers (programmes etc...) vers le RPi
J'ai mis plusieurs procédures. Je vous laisse trier et effectuer une recherche sur le forum:
Lien 1 vers procédure Samba
Lien 2 vers procédure Samba
Lien 3 vers procédure Samba

En gros, voici ce qu'il faut faire:

Code : Tout sélectionner

sudo apt-get install samba samba-common-bin

Il faudra valider par un "y" à un moment donné
Il faudra répondre "Yes" sur une fenêtre bleu

Configuration de Samba:

Code : Tout sélectionner

sudo nano /etc/samba/smb.conf

Copier ceci à la fin du document

Code : Tout sélectionner

[global]
netbios name = Pi
server string = The Pi File Center
workgroup = WORKGROUP

[HOMEPI]
path = /home/pi
comment = No comment
writeable=Yes
create mask=0777
directory mask=0777
public=no

Sauvegarder le fichier avec un "Ctrl-S" puis fermer le fichier avec un "Ctrl-x"

Ensuite il faut modifier le mot de passe Samba

Code : Tout sélectionner

sudo smbpasswd -a pi

Entrer le mot de passe souhaité

Redémarrer Samba avec la commande suivante

Code : Tout sélectionner

sudo service smbd restart

Il est donc maintenant possible d'accéder au dossier "/home/pi" depuis votre PC Windows.
Si vous utilisez un Mac... vous ne devriez pas utilisez un Mac

Pour ouvrir le dossier "/home/pi" ouvrez le poste de travail et taper dans la barre d'adresse:

Code : Tout sélectionner

\\l'adresse_ip_du_RPi

Dans mon cas: \\192.168.0.100

Il faudra entrer le nom d’utilisateur: "pi" et le mot de passe Samba. On peut maintenant y envoyer des fichiers!

La configuration du RPi est maintenant terminée. On va pouvoir créer les programmes qui vont bien pour suivre la procédure.
On va commencer par la lecture et le traitement du code reçu par le lecteur.

[Bull_Eye]

On va donc pouvoir brancher le scanner sur le RPi.
Premier petit soucis, le RPI Zero W possède un port micro USB mais le scanner utilise un connecteur USB type A mâle.


Il faut utiliser un adaptateur USB type A femelle vers micro-USB type B mâle

On en trouve facilement un peu partout sur le web pour très peu cher.

Une fois connecté, il va falloir vérifier que le scanner est bien reconnu.

Code : Tout sélectionner

lsusb

Et vous aller avoir quelque-chose comme ceci

pi@RPiscanner:~ $ lsusb
Bus 001 Device 002: ID 0483:5710 STMicroelectronics Joystick in FS Mode
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

Bus 001 Device 001 correspond simplement au port USB du RPi (utilisé pour les données)
Bus 001 Device 002 correspond correspond au scanner.
C'est donc bon signe, le scanner est reconnu (en tant que joystick??? Oui mais pas gênant).
Pour vous en assurer vous pouvez tester lsusb sans brancher le scanner. Vous n'aurez que le Bus 001 Device 001

Le scanner est considéré comme un périphérique HID.
Pour le voir il faut aller voir ce qu'on a dans le dossier /dev.

Définition:/dev/ - Device 'files'. All devices in Linux are represented by 'files', including disk partitions of any attached hard drives (/dev/hda, /dev/hdb etc), CD ROMs (/dev/cdrom) and memory cards (/dev/sda, /dev/sdb etc).

Code : Tout sélectionner

ls /dev

Vous aurez quelque chose comme ceci

autofs           gpiochip0  loop6               null   ram4     stdout  tty2   tty32  tty45  tty58      urandom  vcsa2     vhci
block            gpiomem    loop7               ppp    ram5     tty     tty20  tty33  tty46  tty59      v4l      vcsa3     video10
btrfs-control    hidraw0    loop-control        ptmx   ram6     tty0    tty21  tty34  tty47  tty6       vchiq    vcsa4     video11
bus              hwrng      mapper              pts    ram7     tty1    tty22  tty35  tty48  tty60      vcio     vcsa5     video12
cachefiles       initctl    media0              ram0   ram8     tty10   tty23  tty36  tty49  tty61      vc-mem   vcsa6     watchdog
char             input      mem                 ram1   ram9     tty11   tty24  tty37  tty5   tty62      vcs      vcsm      watchdog0
console          kmsg       memory_bandwidth    ram10  random   tty12   tty25  tty38  tty50  tty63      vcs1     vcsm-cma  zero
cpu_dma_latency  log        mmcblk0             ram11  raw      tty13   tty26  tty39  tty51  tty7       vcs2     vcsu
cuse             loop0      mmcblk0p1           ram12  rfkill   tty14   tty27  tty4   tty52  tty8       vcs3     vcsu1
disk             loop1      mmcblk0p2           ram13  serial1  tty15   tty28  tty40  tty53  tty9       vcs4     vcsu2
fb0              loop2      mqueue              ram14  shm      tty16   tty29  tty41  tty54  ttyAMA0    vcs5     vcsu3
fd               loop3      net                 ram15  snd      tty17   tty3   tty42  tty55  ttyprintk  vcs6     vcsu4
full             loop4      network_latency     ram2   stderr   tty18   tty30  tty43  tty56  uhid       vcsa     vcsu5
fuse             loop5      network_throughput  ram3   stdin    tty19   tty31  tty44  tty57  uinput     vcsa1    vcsu6

Lorsque le scanner est branché, on a hidraw0 qui apparait.
Si on fait la même manipulation avec le scanner débranché, hidraw0 disparaît.
hidraw0 va nous servir dans le programme.

On va donc pouvoir faire un premier programme pour voir ce que le scanner nous envoie.

[Bull_Eye]

On va d'abord aller chercher la notice du scanner de code-barres Anl 810.
Manuel de programmation en Anglais

La documentation indique dans le chapitre 3 que le scanner peut être connecté avec différents câbles.
Cela est possible car en réalité le scanner a un connecteur RJ50 femelle sur lequel on vient y brancher le câble:
RJ50 mâle" <-> "le connecteur que l'on veut"

Celui que j'ai a un câble:
RJ50 mâle <-> USB type A

Pour vérifier que votre scanner est fonctionnel, vous pouvez le brancher sur votre PC et on va rétablir la configuration usine.
Pour ça il suffit simplement de scanner le code ci-dessous:
Code barre pour réinitialisation

Ensuite on peut ouvrir une feuille excel et scanner le code-barre d'un produit.
Pour mes exemples je vais prendre le code suivant:
3256223378519
C'est du riz bio.

Vous devriez ensuite voir les chiffres apparaître dans la cellule sélectionnée.

La plupart des produits alimentaires utilisent le code EAN-13. 13 chiffres pour le code-barre. Un peu de lecture sur wikipédia

Comme j'ai décidé de rendre le système le plus compact possible, j'ai décidé de démonter le scanner. Je ferai ensuite un boitier imprimé en 3D.
Pour ce qui est du câble, je vais devoir garder le connecteur RJ50 mâle (pas très facile à trouver rapidement sur le net) et donc pour ça j'ai complètement dénudé le câble actuel.
Pour ce qui est du connecteur mirco-usb, j'en ai commandé un sur le web et je vais donc pouvoir couper le câble et refaire la connectique.
câble micro-USB mâle sur Conrad

Je sais pas pour vous mais j'ai toujours une petite hésitation avant de couper un câble parfaitement fonctionnel...
Connecteur RJ50
Câble provisoire
  



D'ailleurs au début, je pensais que c'était un RJ45 mâle. ça m'aurait permis de refaire le câble pour qu'il soit le plus petit possible. J'ai une pince à sertir RJ45 et je n'aurais eu qu'à acheter un connecteur micro-usb.
Sauf que non, ma pince RJ45 ne fait que du RJ45.

On peut donc connecter le scanner au RPi, alimenter le RPi puis créer le programme suivant:
001_lecture_scanner.py

Code : Tout sélectionner

scanner_data = open('/dev/hidraw0')

while True:
	buffer = scanner_data.read(1)
	print (buffer)

On va aller le coller dans le dossier "homepi" du RPi.

hidraw0 fonctionne comme un fichier. Les caractères reçus par le scanner seront disponible dans ce "fichier".La méthode read(1) récupérera un à un ces caractères (byte) pour les afficher dans le terminal.
Voici un lien vers la documentation hidraw mais je ne la trouve pas très claire...
Voici un lien vers la lecture de fichiers avec Python et un autre ici.

Pour info quand je souhaite lire le fichier en entier avec buffer = scanner_data.read(1), je ne reçois rien. Il faut absolument un argument dans la méthode read(). Comme je souhaite récupérer les caractères un à un je mets "1"

Donc ce qu'on va récupérer avec ce bout de code est un peu bizarre et avec plein de retour à la ligne:

" # $ % " & (

Pas très clair tout ça...

On va utiliser la fonction ord() pour avoir un nombre représentant le caractère.(Documentation)
002_lecture_scanner.py

Code : Tout sélectionner

scanner_data = open('/dev/hidraw0')

while True:
	buffer = scanner_data.read(1)
	print ord(buffer)

C'est un peu mieux.
On a plein de 0 et quelques nombres.

32 31 34 35 31 31 32 32 36 37 34 30 38 40

On a 14 nombres qui correspondent à 13 caractères + 1. Il se trouve que dans la documentation du scanner (page 32), on a par défaut, un CR (Carriage Return, Retour chariot) à la fin du code-barre scanné.
Faites le test en scannant un autre produit; Vous aurez toujours 40 à la fin.

On va enlever tous ces 0 de notre code et mettre les nombres sur la même ligne
003_lecture_scanner.py

Code : Tout sélectionner

scanner_data = open('/dev/hidraw0')

code = ""
while True:
	buffer = scanner_data.read(1)
	for character in buffer:
		if ord(character) > 0:
			number = (ord(character))
			code = code + "-" + str(ord(character))
		if number == 40:
			print code

C'est mieux.
On a maintenant ceci:

32-31-34-35-31-31-32-32-36-37-34-30-38-40-

Si on met notre code barre en face on a:

32-31-34-35-31-31-32-32-36-37-34-30-38-40 -
3-2-5-6-2-2-3-3-7-8-5-1-9-    -

Bingo, les chiffres identiques de notre code-barre on des nombres identiques sur le code reçu par le scanner. Il n'y a plus qu'à faire le mapping qui va bien pour avoir les bons chiffres à la place des nombres.

Les nombres reçus par le scanner ne correspondent pas à la table ASCII.
On ne peut donc pas utiliser chr() tel quel sinon on se retrouve avec les caractères bizarres un peu plus haut.

Après avoir cherché sur le web, certains on fait de cette façon:
Exemple de mapping
Autre exemple
Mais la solution est ici.
C'est le HID (human interface device) keyboard mapping qui est utilisé.
On peut retrouver le mapping à la page 54 de ce document

Etant donné que je ne vais utiliser que 10 caractères différents (de 0 à 9), je vais quand même utilser chr() en modifiant quelque peu le code.
Dans la table ASCII, pour avoir un "3" il faut le nombre 51. Or, le scanner m'envoie le nombre 32. Je vais donc simplement ajouter 19 à ce que le scanner m'envoie:
004_lecture_scanner.py

Code : Tout sélectionner

scanner_data = open('/dev/hidraw0')

code = ""
while True:
	buffer = scanner_data.read(1)
	for character in buffer:
		if ord(character) > 0:
			number = (ord(character)) + 19
		if number != 59:			
			code = code + chr(number)
		if number == 59:
			print code
			code = ""

On a maintenant ceci:

3256223378519

ça a l'air bien tout ça!
Sauf qu'il manque quelque-chose: le chiffre "0".
Si vous scannez un code-barre avec le chiffre 0, vous obtiendrez ce caractère ":".

Une dernière modification sur le code:
005_lecture_scanner.py

Code : Tout sélectionner

scanner_data = open('/dev/hidraw0')

code = ""

while True:
	buffer = scanner_data.read(1)
	for character in buffer:
		if ord(character) > 0:
			number = (ord(character)) + 19
		if number == 58:
			number = 48
		if number != 59:			
			code = code + chr(number)
		if number == 59:
			print code
			code = ""

Avec ce dernier code on a exactement ce qu'il nous faut.
Les caractères sont bien reconnus et notre code-barre est complet.

On va pouvoir passer à la suite!

PROGRAMMES.zip

(1.45 Kio) Téléchargé 203 fois

[Zephyre]

Génial comment tu vas gérer la connection à la BDD pour identifier ton code barre ?
Je rêve d'un lecteur comme ça pour refaire les courses.
Et préparer mes listes de courses ou créer des listes de mes bouquins rapidement pareil pour les Jeux.
Je suis ton projet de près

[Bull_Eye]

Génial comment tu vas gérer la connection à la BDD pour identifier ton code barre ?
Je rêve d'un lecteur comme ça pour refaire les courses.
Et préparer mes listes de courses ou créer des listes de mes bouquins rapidement pareil pour les Jeux.
Je suis ton projet de près

Merci !
Le suite arrive très vite !

[Bull_Eye]

La suite va donc être la connexion au site web qui va bien pour récupérer le nom du produit en fonction du code barre.

Pour commencer on va prendre le site Open Food Facts
Il est open source donc tout le monde peut y contribuer.

Open Food Facts est un projet collaboratif auquel participent des contributeurs volontaires du monde entier

N'hésitez donc pas à vous inscrire et à y ajouter les données des produits que vous achetez.

Pour simplifier la récupération de données, on va utiliser leur API JSON Live

Le projet dont je me suis inspiré utilisait les données JSON d'un autre site.
Le site en question ne me convenait pas parce que les informations que je récupérait étaient en anglais.

C'est pour ça que je suis passé par le site Open Food Facts.
Par contre j'ai découvert JSON qui est vachement pratique.
Voici un peu de documentation:
JSON.org
Une vidéo Youtube
Cette vidéo sur Youtube en Anglais m'a été plus utile que les autres.
Celle là aussi est intéressante

Pour récupérer les infos dans un programme Python en JSON provenant d'un site web, il va nous falloir utiliser la librairie Requests

Installation de Requests

Code : Tout sélectionner

sudo apt-get install python-requests

Après un peu de lecture et de visionnage de vidéos, on peut créer un bout de programme pour voir ce que l'on récupère avec notre code-barre.
On va commencer par importer les librairies:
006_donnes_site_web.py

Code : Tout sélectionner

import requests

url = 'https://world.openfoodfacts.org/api/v0/product/' + '3256223378519' + '.json'

page = requests.get(url)
print page.text

Et voici ce qu'on récupère

006-1_donnes_site_web.txt

006-1_donnes_site_web.txt

(19.78 Kio) Téléchargé 221 fois

Pour rendre les données plus lisible on va modifier quelque peu le code et utiliser JSON:
007_donnes_site_web.py

Code : Tout sélectionner

import requests
import json

url = 'https://world.openfoodfacts.org/api/v0/product/' + '3256223378519' + '.json'

page = requests.get(url)
data_url = (json.dumps(page.json(), indent=2, sort_keys=True))

print data_url

Et voici ce qu'on récupère

007-1_donnes_site_web.txt

(29.85 Kio) Téléchargé 219 fois

C'est déjà beaucoup plus lisible!
Et c'est surtout de la donnée JSON valide qui ressemble beaucoup à un dictionnaire Python.

Il va falloir trouver le nom du produit dans ce fichier.
Pour ça j'ai utilisé le module d'extension JSON viewer dans notepad++
Vidéo d'installation
Si on ouvre le JSON Viewer, on va voir la liste des éléments formatés du fichier.


Si on déroule la ligne product et qu'on descend plus bas, on retrouve le nom de notre produit sous product_name_fr


Pour pouvoir faire des recherches dans ces données on va transformer le JSON valide qu'on récupère dans un objet Python avec la méthode json.loads()
C'est là où cette vidéo Youtube en Anglais va nous servir.
On va donc récupérer un dictionnaire Python et ça va être ensuite très simple de récupérer le nom du produit qui nous intéresse.
008_donnes_site_web.py

Code : Tout sélectionner

import requests
import json

url = 'https://world.openfoodfacts.org/api/v0/product/' + '3256223378519' + '.json'

page = requests.get(url)
data_url = (json.dumps(page.json(), indent=2, sort_keys=True))
data_page = json.loads(data_url)

print data_page['product']['product_name_fr']

Bingo! On obtient le nom du produit qu'on pourra ajouter à notre liste de courses.

On verra que par la suite, il faudra également utiliser le status car si ce ne sont pas des produits alimentaire, on ne pourra pas les trouver sur Open Food Facts.
Prenez par exemple le produit suivant (c'est un gel douche):
https://world.openfoodfacts.org/cgi/sea ... on=process
https://world.openfoodfacts.org/api/v0/ ... 56838.json
On obtient ceci:

{"status":0,"code":"8718951156838","status_verbose":"product not found"}

Il sera facile d'adapter le code pour aller chercher sur Open Beauty Facts par exemple:
https://world-fr.openbeautyfacts.org/pr ... nte-tahiti
https://world.openbeautyfacts.org/api/v ... 56838.json

Il faudra également faire attention à certains produits qui ne sont pas complètement renseignés sur le site Open Food Facts
Prenez par exemple le produit suivant (c'est une crème hydratante):
https://world.openfoodfacts.org/api/v0/ ... 83007.json
Le produit possède bien une fiche mais ne renvoie pas de nom de produit.
D'ailleurs il ne devrait pas être sur Open Food Facts mais plutôt sur Open Beauty Facts.
Il faudra adapter le code pour ne pas faire planter le programme si le nom n'est pas trouvé. Et mettre la fiche à jour sur le site correspondant!

On va maintenant pouvoir faire un code pour combiner le scan des produits et la recherche sur le site web. On va même créer des fonctions pour simplifier le code:
009_donnes_site_web.py

Code : Tout sélectionner

import requests
import json



##########################################################################################
# FONCTION POUR RECUPERER LE CODE BARRE
##########################################################################################
def barcode_reader():
	code = ""
	done = False

	fp = open('/dev/hidraw0', 'rb')
	while not done:
			buffer = fp.read(8)
			for c in buffer:
				if ord(c) > 0:
					e = (ord(c)) + 19  
					if e == 58:	
						e = 48
					if e != 59:			
						code = code + chr(e)
					if e == 59:
						done = True
	return code
	
##########################################################################################
##########################################################################################
##########################################################################################



##########################################################################################
# FONCTION POUR RECUPERER LE NOM SUR OPENFOODFACTS EN JSON
##########################################################################################
def off(off_result):

	url = 'https://world.openfoodfacts.org/api/v0/product/' + off_result + '.json'
	page = requests.get(url)
	data_url = (json.dumps(page.json(), indent=2, sort_keys=True))
	data_page = json.loads(data_url)
	if  (data_page['status']) == 1:
		name = (data_page['product']['product_name_fr'])
		
		return name
	else:
		name = 0
		return name

##########################################################################################
##########################################################################################
##########################################################################################



##########################################################################################
# CODE FINAL
##########################################################################################

# Boucle pour la recherche du nom du produit
while True:  
	barcode = barcode_reader()
	print (barcode)
	off_product_name = off(barcode)
	
	if off_product_name == 0:
		print ("Le produit n'a pas ete trouve")
	else: 
		print off_product_name
	

Il ne vous reste plus qu'à aller chercher tous vos produits avec code-barre dans votre cuisine pour les tester.
C'est déjà une bonne chose de faite.Prochaine étape, importer le nom du produit dans Google Keep.

N'hésitez pas à commenter!

[Zephyre]

Énorme merci pour le détail je vais l'y lettre parcontre existent ils des douches que l'on peut connecter sans traficouillage ?

[Zephyre]

Ce qui serait top c'est d associer ton fichier de courses pour l'intégrer en masse dans ton panier de ton drive par exemple.
Je me suis pas renseigner.
Je sais pas si ils le font