IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Windows Forms Discussion :

Echange d'un string entre deux process (Windows vs Labview)) [Débutant]


Sujet :

Windows Forms

  1. #1
    Futur Membre du Club
    Profil pro
    Inscrit en
    Février 2010
    Messages
    6
    Détails du profil
    Informations personnelles :
    Localisation : France, Yvelines (Île de France)

    Informations forums :
    Inscription : Février 2010
    Messages : 6
    Points : 8
    Points
    8
    Par défaut Echange d'un string entre deux process (Windows vs Labview))
    Bonjour,
    LE PROBLEME.
    Je souhaiterai créer un programme capable d’acquérir des commandes vocales sous "WindowsForms en C#" et d'envoyer le "string" obtenu de 20 caractères maximum pour les communiquer je ne sais encore comment, à un programme Labview qui ne sait lire apparemment que dans les registres et les fichiers textes de Windows (je suis débutant).

    LA DIFFICULTE.
    Bien que tout fonctionne à merveille, coté reconnaissance vocale (avec using System.Speech.Recognition; ) ,
    A l'heure actuelle, je suis incapable de lire, avec Labview, le fichier texte créé par mon process WindowsForms (qui tourne en permanence),
    car mon process Labview me dit toujours que le fichier est pris par mon process WindowsForms.

    MA SOLUTION en C# (qui ne parche pas).
    j'ai pourtant déclaré "sharable" mon fichier Windows Form, comme suit :

    private const string pathWrite = @"c:\temp\VoixWrite.txt";
    FileStream fsWrite = new FileStream(pathWrite, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite);


    etc.
    //========================
    // Je précise que, quand le process WindowsForms (Je donnerai le code plus tard quand j'aurai résolu ce problème) a compris un mot, il le met dans "e.Result.Text"
    //========================

    // Le process WindowsForm exploite ce mot 'vocal' transformé en string dans "e.Result.Text" de la façon suivante :
    // d'abord on attend que Labview ait exploité le mot précédent écrit dans le fichier "c:\temp\VoixWrite.txt"

    while (File.Exists(pathWrite))
    {
    //On attend, tant que le fichier n'est pas détruit par Labview;
    }

    // Quand le fichier a été exploité par Labview, Labview le détruit, on sort donc de la boucle

    using (StreamWriter sw = File.CreateText(pathWrite))
    {
    sw.WriteLine(e.Result.Text);
    sw.Close();
    }

    =========================================

    C'est l'apparition du fichier créé et écrit par WindowsForms et lu puis détruit par Labview qui assure la sécurité de la transaction.

    MAIS VOILA.

    Mon process Labview est incapable d'ouvrir et encore moins de détruire le fichier "c:\temp\VoixWrite.txt" créé et mis à jour par le process WindowsForms;

    Au secours Luc, la force n'est pas avec moi :O
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    Possibilités Numéro 2 et 3, je n'ai pas essayé le passage par variable d'environnement ou par les Registres Windows (et autres que je ne connais pas...) . Mais je suppose que je rencontrerai le même problème de sécurité.

    MA CONTRIBUTION.
    Une commande Vocale très utile dans le cas ou le clavier et la souris - non hookables, sont utilisés/capturés/piegés par un jeu utilisant directInput (par exemple) ou programmé en LINUX (je crois).
    Afin de pouvoir utiliser d'autres applications réalisées par n'importe quels programmeurs sachant manipuler des fichiers et capables de lire et d'interpretter les commandes vocales transcrites dans le fichier d'échange (ici C:\temp\VoixWrite.txt).


    Je mettrai un source basique sous WindowsForms en C# (donc facile à adapter) , en ligne sur ce site, dès que j'aurai un process WindowsForm qui tourne.


    Merci d'avance.

  2. #2
    Futur Membre du Club
    Profil pro
    Inscrit en
    Février 2010
    Messages
    6
    Détails du profil
    Informations personnelles :
    Localisation : France, Yvelines (Île de France)

    Informations forums :
    Inscription : Février 2010
    Messages : 6
    Points : 8
    Points
    8
    Par défaut Voici ma première réponse à moi-même ???????
    Bonjour,

    Néanmoins je laisse ici ma première solution, qui marche bien, et qui permettront au débutant de faire leur premier pas dans la reconnaissance vocale de Microsoft sous Windows (8 en ce qui me concerne).

    using System;
    using System.IO;
    using System.Text;
    using System.Windows.Forms;
    using System.Speech.Recognition;

    // après la détection d'un mot 'parlé' ce logiciel envoi le mot 'écrit' trouvé soit dans le tableau de mots fixes'Constante'
    // ou dans le fichier personnalisable désigné par 'path', dans un fichier 'pathtarget' accessible par tout process externe.
    // le process externe doit détruire le fichier 'pathTarget' aussitot lu, pour son application, ASSEZ RAPIDEMENT.
    //
    // Exemple de fichier de mots complémentaires créés avec NotePad dans path = AlainSearchSavage.txt
    // On notera en deuxieme colonne la prononciation à la française.
    //
    // syntaxe : colonne_mot_écrits'tab'...'tab'colonne_mot_parlé
    // début du fichier >>>>>>>>>>>
    // !libre libre
    // #forcreate# forcrite
    // #forlieu# forlieu
    // #forrepair# forriper
    // alt
    // ammu ammo
    // app
    // arsenal
    // etc.
    // La séparation entre le mot et sa phonétique est faite avec une ou plusieurs 'tab' pour ds raisons de présentation
    // le mot parlé doit obligatoirement être suivi d'un retour à la ligne sans 'tab' (invisible)
    // si le mot parlé n'existe pas, c'est que le mot écrit suffit à sa détection par le système de recherche vocale.
    //
    // ======================================================================================================================================
    // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< IMPERATIVEMENT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    //=======================================================================================================================================
    // lors de la création du projet WindowsForm sous C#, ne pas oublier d'ajouter System.Speech dans les références
    // et bien sûr, ne pas oublier d'activer votre micro et de 'réveiller' votre logo "micro" de microsoft. qui est appelé par ce process.
    // si le logo du système de reconnaissance de Microsoft n'est pas sur le bureau, et si vous n'avez pas suivi le didacticiel d'apprentissage
    // du système de reconnaissance de Microsoft. Il est impératif de l'installer (taper "Reconnaissance Vocale" sur le système de recherche de
    // votre ordi pour l'installer et, activer le didacticiel qui permettra à votre ordi de reconnaitre votre voix)
    //=======================================================================================================================================
    // Personnellement, j'ai pas mal bricolé et j'ai installé par ailleurs les deux logiciels suivants :
    // sous toutes réserves début ===========================================================================================================
    // SpeechPlatformeRunTime.msi et probablement le SDK Speech Microsoft C# et tout aussi probablement le KinectSpeechLanguagePack_fr-FR.exe
    // sous toutes réserves fin =============================================================================================================
    // MAIS BIEN ENTENDU, je ne suis pas sûr que ce soit nécessaire. EN TOUT CAS, le process ci-dessous, simplifié à l’extrême, marche A MERVEILLE.
    // à vous d'en faire ce que bon vous semble, par exemple ajouter un filtre sur le mot proposé 'logMessage' pour s'assurer qu'il corresponde
    // à un des mots souhaité (car le système de reconnaissance vocal détecte aussi les mots de son propre dictionnaire et de ceux acquis par
    // votre apprentissage, lors de son installation (je crois ). Ça reste à confirmer bien sûr.
    //
    // ======================================================================================================================================
    // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< UTILISATION PAR LE CONSOMMATEUR >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    //=======================================================================================================================================
    // LE CONSOMMATEUR qui peut être un process externe indépendant, mais capable de lire un fichier texte Windows,
    // n'a plus qu'a ouvrir, lire et détruire le fichier 'pathTarget' et en fonction des mots reçus, agir sur son programme pour :
    // >>>>>>>>>>>>>>> avec le premier mot, agir sur la première rangée du menu,
    // >>>>>>>>>>>>>>> avec le deuxième mot, agir sur la deuxième rangée du menu, et selon le cas
    // >>>>>>>>>>>>>>> avec son troisième et quatrième mots peaufiner sa recherche (alphabétique ou non) avec les numéro de lignes, s'il désire
    // sélectionner une ligne parmi les lignes proposées
    //=======================================================================================================================================

    // NOTA: ce process de base est destiné à être adapté et complexifié par vous. Notamment en installant des filtres sur les mots détectés
    // si c'est nécessaire, car le système de reconnaissance vocale de Microsoft peut proposer des mots de son propre vocabulaire.
    // Ce n'est pas critique car le consommateur peut aussi les filtrer (ou les rejeter).
    //

    namespace voixSavage_v1._01
    {
    public partial class Form1 : Form
    {
    string pathTarget = @"c:\temp\VoixWrite.txt"; //volontairement mis sur C: qui est une disque rapide (SSD )
    string pathWordPlus = @"F:\Jeux\Savage\game\AlainSearchSavage.txt"; // chargé une seule fois. peut être partout
    public Form1()
    {
    InitializeComponent();
    }
    private void Form1_Load(object sender, EventArgs e)
    {
    // Create a new SpeechRecognitionEngine instance.
    SpeechRecognizer recognizer = new SpeechRecognizer();

    // les mots complémentaires sont dans le fichier ci-dessous
    // string path = @"F:\Jeux\Savage\game\AlainSearchSavage.txt";
    // string pathTarget = @"c:\temp\VoixWrite.txt";

    string[] Phonetique = new string[0];
    // les mots fixes sont ici
    string[] Constante = new string[] {
    // correspond à un système de recherche, cela permet de choisir une des 27 lignes par l'application consommatrice
    // d'abord le système de recherche alphabétique de base (qui sera complété/affiné par les mots complémentaires de 'path'
    "zéro", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "Plus", "Moins",
    // ensuite un système de sélection d'une ligne parmi 27 lignes de base
    "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", "dix", "onze", "douze", "treize", "quatorze", "quinze", " seize", "dix-sept", "dix-huit", "dix-neuf",
    "vingt", "vingt-un", "vingt-deux", "vingt-trois", "vingt-quatre", "vingt-cinq", "vingt-six", "vingt-sept",
    // correspond à la premiere rangée de menus du consommateur
    "app", "shift", "control", "nothing", "all",
    // correspond à la deuxième rangée de menus du consommateur
    "KeyPad", "Function", "Nostromo", "Compass", "Search", "APPSup", "ALTSup", "SHIFTSup", "CONTROLSup", "MAP", "Pat"};
    try
    {
    if (File.Exists(pathWordPlus))
    {
    using (StreamReader sr = new StreamReader(pathWordPlus))
    { // on fabrique le tableau 'Phonétique' contenant les mots complémentaires que devra comprendre la reconnaissance vocale de Microsoft
    // on extrait les mots de la deuxième colonne de chaque ligne de 'path'
    while (sr.Peek() > 0)
    {
    string[] PhonetiqueNew = new string[Phonetique.Length + 1];
    for (int i = 0; i < Phonetique.Length; i++)
    {
    PhonetiqueNew[i] = Phonetique[i];
    }
    Phonetique = PhonetiqueNew;
    // Le fichier est de ligne correspondant à un mot. la partie droite correspond à l’orthographe écrit, la partie droite à sa phonétique
    // que l'on doit mettre dans la grammaire du Speech. On y ajoutera les mots fixés une fois pour toutes ci-dessous.
    // exemple : cette partie variable est dans le fichier AlainSearchSavage.txt
    // "Ripair", "Crite", "Research", "Ballista", "Magnetic", "Workshop", "Chemical", "Electric", "Ammo", "Sensor", "Pulse Cannon", "Catapult", "Garrison", "Subler",
    // "Attack", "Workers", "Shield",
    string[] phraseDecoupe = sr.ReadLine().Split('\t');
    if (phraseDecoupe.Length < 2)
    {

    string[] phraseDecoupeNew = new string[phraseDecoupe.Length + 1];
    phraseDecoupeNew[0] = phraseDecoupe[0];
    phraseDecoupeNew[1] = phraseDecoupe[0];
    phraseDecoupe = phraseDecoupeNew;
    }
    //il ne faut pas de tab après la phonétique
    phraseDecoupe[1] = phraseDecoupe[phraseDecoupe.Length - 1];
    Phonetique[Phonetique.Length - 1] = phraseDecoupe[1];
    }
    }
    // concatenation des deux tableaux (celui des mots fixes et des mots complémentaires)
    string[] savageCmd0 = new string[Phonetique.Length + Constante.Length];
    Phonetique.CopyTo(savageCmd0, 0);
    Constante.CopyTo(savageCmd0, Phonetique.Length);
    //============================================== Fin de la construction de la liste des mots ====================================
    // le résultat est dans savageCmd0
    //===============================================================================================================================

    // passage de ces mots'vocaux' au système de reconnaissance vocale de Microsoft
    Choices Cmd = new Choices(); // partie fixée par le process
    // Create a GrammarBuilder object and append the Choices object.
    Cmd.Add(savageCmd0);
    GrammarBuilder gb = new GrammarBuilder();
    gb.Append(Cmd);

    // Create the Grammar instance and load it into the speech recognition engine.
    Grammar g = new Grammar(gb);
    recognizer.LoadGrammar(g);

    // Register a handler for the SpeechRecognized event.
    recognizer.SpeechRecognized +=
    new EventHandler<SpeechRecognizedEventArgs>(sre_SpeechRecognized);
    }
    else
    Console.WriteLine("The search file {0} dont exist", pathWordPlus);

    }
    catch (Exception f)
    {
    Console.WriteLine("The process failed: {0}", f.ToString());
    }
    }

    // Create a simple handler for the SpeechRecognized event.
    void sre_SpeechRecognized(object sender, SpeechRecognizedEventArgs e)
    {
    // using (StreamWriter w = File.AppendText(@"c:\temp\VoixWrite.txt"))
    using (StreamWriter w = File.AppendText(pathTarget))
    {
    Log(e.Result.Text, w);
    // 1) VOUS POUVER INSTALLER VOTRE CODE ICI, le mot proposé par la reconnaissance vocale est le string 'e.Result.Text'
    // bla bla bla
    // ou dans Log() ci-dessous

    }
    }
    public static void Log(string logMessage, TextWriter w)
    {
    w.Write("{0}, ", logMessage);
    //2) VOUS POUVER INSTALLER VOTRE CODE ICI, le mot proposé par la reconnaissance vocale est le string 'logMessage'
    // bla bla bla
    }
    }
    }


    NOTA : personnellement j'ai modifié le code ci-dessus pour que la fonction Log() envoi directement le mot 'écrit' (colonne de droite) et ne fait rien (c'est à dire n'écrit pas de fichier) si le mot 'entendu' ne correspond pas à ma table car le système de reconnaissance vocale de Microsoft à la fâcheuse tendance, lorsqu'il ne reconnait pas un mot à partir du vocabulaire défini dans ce programme (ci-dessus) de proposer des mots pris dans sa propre table, défini lors du déroulement de son tutorial, lors de son installation dans le PC.
    Autre remarque. Comme la reconnaissance vocale est nettement francisé, j'ai parfois été obligé de coller une phonétique française en face du mot anglais. Ainsi j'ai du/pu écrire ceci,
    ...
    deploy \t deploy
    draw for \t dro
    draw for \t drofor
    draw for \t trace
    efface
    ... etc.

    On constatera que pour 'passer' la commande 'Draw for' en bon anglais, j'ai pris la précaution de réécrire 3 phonétiques différentes. Au moins, quelque soit mon stress, j'étais sûr que ma commande vocale à fort accent français 'passerait'.

    Pour ce qui est du reste..; Je ne suis pas mécontent de mon travail. Tout marche à merveille.
    le programme producteur, largement dérivé du programme ci-dessus est quasiment terminé.
    Maintenant je me 'colle' au programme consommateur qui 'cause(ra)' à mes jeux préférés. ET TOUT CA sans Déranger ma souris et mon clavier, qui la plupart du temps sont "capturés" par les jeux
    et donc inutilisables en dehors de l'écran du jeu

  3. #3
    Membre chevronné
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Avril 2009
    Messages
    1 048
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Finance

    Informations forums :
    Inscription : Avril 2009
    Messages : 1 048
    Points : 2 201
    Points
    2 201
    Par défaut
    A priori si tant que tu ne clos pas le fichier dans ton application Winforms, tu risques d'avoir des problème à l'ouvrir ailleurs. Particulièrement si c'est dans l'optique de le détruire.

    Soit tu crées un fichier par ordre recu par winforms et détruit ensuite par LabView après exécution.

    Soit tu partage le fichier entre les 2 système par des opération d'ouverture et de fermeture de la ressource (le fichier). Il faudra prévoir dans ce cas un système de buffer pour stocker temporairement les commandes vocal si LabView est en train traiter les commandes précédantes.

    Peut être que quelqu'un d'autre te donnera une solution pour utiliser un fichier de text comme une solution FIFO.

  4. #4
    Futur Membre du Club
    Profil pro
    Inscrit en
    Février 2010
    Messages
    6
    Détails du profil
    Informations personnelles :
    Localisation : France, Yvelines (Île de France)

    Informations forums :
    Inscription : Février 2010
    Messages : 6
    Points : 8
    Points
    8
    Par défaut
    Bonjour,
    Probablement j'aurai un jour un problème, le probabilité de collision liés aux accès "simultanés" bien qu'infimes, sont possibles ... Je cogite encore sur ce problème.

    il y a probablement des solutions.

    A) Je ne sais pas si on parle de la même chose...
    FIFO : First In First Out
    solution 1 : Comment créer cette FIFO


    B) Je pensais aussi à une autre solution :

    Un process tier qui jouerai le rôle de chef de gare et passerait les permissions d’accès à l'un ou à l'autre des deux process "consommateur" vs "producteur".

    Mais je ne vois pas comment créer un sémaphore que "TOUT LE MONDE" peut lire, sans avoir ce même problème d’accès simultané au "sémaphore". :

    Ma question devient donc la suivante :
    solution 2 : Comment créer un sémaphore (boolean : fichier ou clé du registre windows) accessible par tout le monde, même simultanément, sachant que l'opération "lecture/blocage" doit absolument pouvoir s'enchainer sans être interrompu, dans tous les sens du terme, par le système.



    ===========================================================
    RETOUR AU PROBLEME : Je rappelle qu'il s'agit de faire "dialoguer" deux process, dont l'un, ne connait absolument pas l'environnement Windows Form.. Leur seul moyen de communication étant les fichiers ou une les clés du registre Windows.
    J'avais pourtant espérer avoir trouver un moyen très simple de communication en déclarant "sharable" (donc accès en lecture 'simultanée' possible) mon fichier. Bien que mon programme marche merveilleusement. J'ai encore des doutes ...
    C'est pour cette raison, que j'aimerai continuer à "alimenter" ce fil de discussion... probablement sur les deux thèmes : Les FIFO suggérés par mon éminent collègue ci-dessus et les fichiers 'sharables' ma stupéfiante et incroyable idée de votre serviteurs.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 1
    Dernier message: 31/01/2007, 11h00
  2. [SAX] Comment récupérer un String entre deux balise xml?
    Par L4BiN dans le forum Format d'échange (XML, JSON...)
    Réponses: 6
    Dernier message: 23/06/2006, 10h02
  3. Réponses: 14
    Dernier message: 02/05/2005, 19h14
  4. partager ressource entre deux process
    Par buzzz dans le forum Windows
    Réponses: 6
    Dernier message: 16/02/2005, 11h36
  5. TList partagée entre deux process.
    Par swirtel dans le forum C++Builder
    Réponses: 2
    Dernier message: 10/01/2005, 12h48

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo