electro575 a écrit 888 commentaires

Il est dispo seulement pour la compilation gcc mais non avec g++ sous QtCreator.

J'ai déjà testé hors QtCreator avec Omnidriver. Ca fonctionne

je suis bloqué pour faire du multithread avec mon logiciel d'ailleurs!

Je voulais dire par la que je suis entrain de développer la communication un thread pour ça et un pour la gestion de l'interface graphique.

tu utilises donc ton propre code pour dialoguer avec l'appareil

Non, j'utilise les fonctions C++ de SeaBreeze pour dialoguer avec l'appareil.

si tu utilises un logiciel fournit par le fournisseur oceanoptics,
tu as aussi le "bug" sur l "USB400", ou bien tu as ces erreurs de données uniquement avec ton logiciel ?

Si j'utilise un logiciel de chez eux on aurait pas ce problème car ils doivent utiliser Omnidriver avec Mcirosoft Visual Basic et Omnidriver n'est compatible uniquement avec le compilateur C++ MSVC. J'utilise SeaBreeze pour développer mon logiciel sous QtCreator.

Je vais tester les manips que tu me dis dès que j'ai du temps pour ça.

Le blacklister ne servirait à rien alors visiblement !

Je l'ai compilé sur une machine 64 bits.

L'erreur, il n'y en a pas. Enfin, je sais juste observer que les valeurs que je récupère ne sont pas les bonnes. Après je n'ai pas regardé plus loins encore à ce niveau la.

En ce moment je suis bloqué pour faire du multithread avec mon logiciel d'ailleurs! Mais ça c'est une autre histoire

il faut revoir le protocole de test.

Qu'entends-tu par protocole de test?

tu compiles le driver

Tu parles de SeaBreeze?

• soit utiliser un programme que tu sais fonctionner sur une autre machine et l'utiliser sur la machine ou tu testes le driver
• soit faire le programme le plus basic possible,

J'ai pas très bien saisi ce que tu voulais dire!

---

Ce que je peux assurer c'est que SeaBreeze fonctionne avec un matériel mais pas avec l'USB4000 de leur gamme sous Linux.

En fait je lance le protocole d'acquisition classique pour récupérer deux tableaux.

Un tableau concernant les nanomètres
Un tableau concernant les intensités
Tous deux de taille 3648 pour le matériel USB4000

Lorsque je fait un printf du tableau de nanomètre, j'obtiens des valeurs incompréhensible! Mon professeur m'a dit que c'était peut être du à une incompatibilité avec le driver USB sous Linux (ou alors vstmod). Je ne sais pas …

Merci pour ta réponse. J'ai pris SeaBreeze sur ce lien la : SeaBreeze

Je n'ai pas pris le temps de regarder le support pour le moment

Merci beaucoup pour tes précisions. Bonne fin de journée à toi !

Je n'avais pas testé le code de la personne pour le premier lien. Il s'avère que son programme peut lister les périphériques USB.

A moi d'adapter le code à mon application.

Le deuxième lien m'a permit de faire tourner le démon usb.

Une personne m'a indiqué cette librairie pour la communication USB multiplatforme :

Libusb

Merci à toi

Merci à toi

Je pensais peut être qu'avec la description suivante, que je puisse utiliser la fonction udev_monitor_filter_add_match_tag(struct udev_monitor *udev_monitor, const char *tag);

TAG : Attach a tag to a device. This is used to filter events for users of libudev's monitor functionality, or to enumerate a group of tagged devices. The implementation can only work efficiently if only a few tags are attached to a device. It is only meant to be used in contexts with specific device filter requirements, and not as a general-purpose flag. Excessive use might result in inefficient event handling.

Par contre, j'aurais dit comme ceci la syntaxe mais je ne suis pas sur :

ATTRS{idVendor}=="", ATTRS{idProduct}=="", SYMLINK+="", TAG:="essai", MODE:=""

Liens :
LibUdev
Syntaxe_rules

Oui j'ai lu cette page mais pas entièrement.

L'outil udevadm est bien utile.

Je connais déjà le subsystem et le devtype de mon appareil grâce à un programme, je cherche plutôt à mettre un TAG ou alors créer un groupe dans le .rules afin de noter plusieurs périphériques particuliers dont j'aimerais noter les caractéristiques dans mon interface.

Pour le TAG j'ai :
udev_monitor_filter_add_match_tag (struct udev_monitor *udev_monitor, const char *tag);

Pour Subsystem et Devtype j'ai :
udev_monitor_filter_add_match_subsystem_devtype (struct udev_monitor *udev_monitor, const char *subsystem, const char *devtype);

Avec d'autres paramètres je ne peux rien faire. Comme ajouter un groupe je ne sais pas si ça va changer Devtype par exemple…

Voila le lien de la libudev : libudev

Avec ce lien, je ne pense pas qu'il existe de bibliothèque Qt permettant la discussion par USB sur toutes les platformes.

Texte du lien

Problème : la lib qui récupère les infos de mon matériel n'est pas compilable en C++

Solution :
-soit faire un programme pour la gestion de l'USB sous Linux
-soit utiliser une bibliothèque QtCreator pour l'USB, peut être QSerialPort pour gérer l'USB pour toute les platforme et appeler ensuite le programme qui va interroger le matériel.

La deuxième solution serait l'idéal.

Ha ben j'ai pas penser directement passer par une lib Qt pour discuter depuis tous les OS en USB mais effectivement …

Je vais me diriger vers cette option multiplatforme.

Un grand merci, je vous ferais un retour dès que ça fonctionne!

Bonne fin de semaine à vous tous

Solution, connaitre le PID sous le processus lancé de l'interface.cpp !

Peut être que j'arriverai à faire quelque chose et encore c'est pas trop sur

Je comprends ce qu'il veut faire sauf pour monusb.sh et la ligne de code suivante :

/bin/stty -F /dev/$1 57600

fichier /etc/udev/rules.d/70-monusb.rules :

    UBSYSTEMS=="usb", KERNEL=="ttyUSB?",
    ATTRS{interface}=="??",MODE="0666", SYMLINK+="monusb", RUN+="/bin/monusb.sh %k"**

fichier /bin/monusb.sh :

    #!/bin/bash

    sleep 1

    /bin/stty -F /dev/$1 57600
    /bin/stty -F /dev/$1 -icanon
    /bin/stty -F /dev/$1 min 1

L'inconvéniant est que sous QtCreator, je sais lancer un processus en parallèle (ou fils) et lire la sortie standard du processus fils avec l'entrée standard du processus père.

Maintenant, je veux bien lancer un script depuis le .rules avec la commande RUN+="…"
Le souci c'est que je ne sais pas comment créer un tube entre le processus lancé depuis le .rules et le processus père (interface.cpp)

Désolé pour l'affichage … c'est du copie colle!

Pour l'USB dumping, je ne connais pas le langage python mais peut être que je vais m'y mettre.

Je viens de le décompresser !

Des astuces pour compiler tout ça ? comment on se sert des fichiers pythons

Après une lecture du site d'ubuntu à propos de Udev et de la syntaxe des fichiers .rules, je pense qu'il suffi de surveiller avec un démon si un fichier se créé au chemin /dev/truc et après lancer les commandes à partir d'un fichier.

Je ne sais pas si surveiller en permanence si un fichier existe peut poser problème, ou s'il se créé !

En te remerciant. Je vais regarder tout ça ce matin

Okey, je vais regarder ça dès que j'ai du temps.

En te remerciant, bonne journée à toi

J'ai remplacé mon code pere.cpp :

        char buf [10];

        FILE *pp;

        pp = popen("/home/jo-pc/Bureau/STAGE/Projet_spectro/pipe/test_3/fils", "r");

        if (pp == NULL)
        {
                perror("popen");
                exit(1);
        }
        printf("etape1");
        while (fgets(buf, sizeof(buf), pp))
                fputs(buf, stdout);
        pclose(pp);
        printf("etape2");
        printf("%s",buf);

Ainsi, j'ai :
etape1coucou
etape2coucou

Je pense donc que c'est correcte. popen créé un pipe entre les deux fichiers et lit sur l'entrée standard du process fils.

Autre méthode qui marche pour le pere.cpp via ce lien en utilisant les E/S standard : Texte du lien

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#include <fcntl.h>
#include <sys/stat.h>

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

//#define BUFSIZ 20

int main()
{
 /* create the pipe */
 int  fds[2];
 if (pipe(fds) == -1)
   {
     printf("pipe failed\n");
     return 1;
   }

 /* create the child */
 int  pid;
 if ((pid = fork()) < 0)
   {
     printf("fork failed\n");
     return 2;
   }

 if (pid == 0)
   {
     /* child */
     //char buffer[20];

     close(fds[0]);
     dup2(fds[1], STDOUT_FILENO);
     execl("/home/jo-pc/Bureau/STAGE/Projet_spectro/Projet_spectro_1/Test/Acquisition","Acquisition",NULL);
     close(fds[1]);


   }
 else
   {
     /* parent */
     waitpid(pid,NULL,0);
     char buffer[1000];

     close(fds[1]);
     dup2(fds[0], STDIN_FILENO);

     while (read(fds[0], buffer, 1000) != 0)
       printf("%s\n", buffer);

     close(fds[0]);

       //printf("%s", buffer);       printf("%s", buffer);       printf("%s", buffer);
    std::cout << buffer << std::endl;

   }

 return 0;
}

Ca fonctionne bien pour le moment. Je vais continuer d'exploiter ceci. Je fairais un retour. Merci beaucoup

Une solution à mon problème existe. La fonction popen, elle permet de créer un pipe entre deux fichiers et remplace les fonctions fork, execl, dup2, …

pere.cpp :

    int main()
{
        char buf [10];

        FILE *pp;

        pp = popen("fils", "r");

        if (pp == NULL)
        {
                perror("popen");
                exit(1);
        }
        while (fgets(buf, sizeof(buf), pp))
                fputs(buf, stdout);
        pclose(pp);

return 0;
}    

fils.c :

    int main()
{
        fprintf(stdout,"coucou\n");
        fflush (stdout);
    return 0;
}    

On obtient bien coucou de la part du fils sur la sortie standard (console)!
L’inconvénient c'est que je ne maitrise pas ce que je fais avec cette fonction.

Je ne sais pas si passer par la sortie standard c'est très approprié … ce n'est peut être pas très propre à la longue!
Je vais chercher du côté des redirection de tube ou de la mémoire partagée pour deux processus afin de garder la déclaration du descripteur pour le fils une fois execl dans le père lancé.