Problème commun
Javacomm et RXTX ont des choses différentes lors de l'installation. Il est fortement recommandé d'installer une petite installation conformément aux instructions d'installation. Si les instructions d'installation nécessitent un fichier JAR ou une bibliothèque partagée doit être sous un dossier spécifique, ce qui signifie qu'il doit être pris au sérieux. Si un fichier ou un appareil spécifique doit avoir une propriété ou un droit d'accès spécifique, cela signifie également qu'il doit être traité sérieusement. De nombreux problèmes d'installation sont causés par le fait de ne pas conforme aux exigences des instructions d'installation.
Il convient de noter que certaines versions de Javacomm auront deux instructions d'installation. L'un est utilisé pour Java 1.2 et plus tard, un pour la version Java 1.1. L'utilisation des mauvaises instructions d'installation entraînera le résultat d'installation qui ne peut pas être travaillé. D'un autre côté, certaines versions / composants / packages de TXTX contiendront des descriptions incomplètes. Dans ce cas, il est nécessaire d'obtenir le code source publié par RXTX, qui contient des instructions d'installation complètes.
De plus, il convient de noter que le programme d'installation JDK de Windows contiendra trois machines virtuelles Java, il y aura donc trois dossiers étendus.
De plus, même le quatrième JRE, qui existe dans la structure du répertoire de / Windows. Javacomm devrait être installé dans JDK et tous les extensions publiques en JRE.
Chanteur en ligne
Javacomm
Un problème commun à propos de Javacomm et RXTX est qu'ils ne prennent pas en charge l'installation via Java WebStart: la tristement célèbre de Javacomm est parce que vous devez appeler un fichier appelé javax.com.properties au répertoire JDK Lib, et cela ne peut pas être terminé via Java webstart. Il est très frustrant que le besoin de ce fichier soit des conceptions inutiles à Javacomm, et les concepteurs de Javacomm peuvent facilement éviter cela. Sun a obstinément rejeté l'erreur, et ils ont souligné que ce mécanisme est essentiel. Ils parlaient des bêtises, surtout lorsqu'ils ont mentionné Javacomm, parce que Java avait une architecture de fournisseur de services spécialisée dans de telles intentions depuis longtemps.
Il n'y a qu'une seule ligne dans le contenu de ce fichier d'attribut, qui fournit un nom de classe Java basé sur local.
Driver = com.sun.win.win32driver
Ce qui suit est une technique qui peut déployer Javacomm via le Web Start pour ignorer le fichier d'attribut qui nuise au cerveau. Mais il a de sérieux défauts et peut échouer lors du déploiement d'un nouveau Javacomm-si Sun fera une nouvelle version.
Tout d'abord, éteignez le responsable de la sécurité. Certains programmeurs stupides de Sun pensaient que l'existence des terribles fichiers javax.comm.properties était cool encore et encore, surtout quand il a été chargé pour la première fois. Cela vérifie simplement si le fichier existe sans autres raisons.
System.SetSecurityManager (null);
Ensuite, lorsque l'API Javacomm a été initialement démarrée, initialisé manuellement le conducteur.
String DriveName = "com.sun.comm.win32driver";
Rxtx
RXTX doit modifier la propriété et accéder à la droite du périphérique série sur certaines plates-formes. C'est aussi une chose qui ne peut pas être fait via WebStart.
Lorsque le programme démarre, vous devez demander aux utilisateurs d'effectuer les paramètres nécessaires en tant que super utilisateurs. En particulier, RXTX a un algorithme de correspondance de mode pour vérifier le nom de l'équipement de série "légal". Lorsque quelqu'un veut utiliser des appareils non standard, comme le convertisseur USB-TO-SERE, cela gâche souvent les choses. Ce mécanisme peut être bloqué par les attributs du système. Pour plus de détails, reportez-vous aux instructions d'installation de RXTX.
API Javacomm
introduction
L'API officielle de communication série officielle de Java est l'API Javacomm. Cette API ne fait pas partie de la version standard de Java 2, donc l'implémentation de cette API doit être téléchargée séparément. Malheureusement, Javacomm n'a pas attiré suffisamment d'attention au soleil et le temps de maintenance réel n'était pas très long. Sun vient de réparer des insectes sans importance à l'occasion, mais n'a pas fait un entretien important qui a longtemps expiré.
Cette section explique le fonctionnement de base de l'API Javacomm. Le code source fourni est simplifié pour afficher l'objectif et il doit être amélioré dans les applications pratiques.
Le code source de ce chapitre n'est pas le seul exemple de code disponible. De nombreux exemples contiennent des téléchargements Javacomm. Ces exemples incluent plus d'informations sur la façon de l'utiliser que ses documents API. Malheureusement, Sun n'a pas de véritable tutoriel ni de documents d'explication. Par conséquent, pour comprendre le mécanisme de cette API, l'apprentissage de ces exemples en vaut la peine, et vous devez toujours apprendre ce document API. Mais la meilleure façon est d'apprendre ces exemples et de les utiliser. En raison du manque d'applications faciles à utiliser et de la compréhension du modèle de programmation de ces API, les API sont généralement attaquées. Par rapport à sa réputation et à sa fonction, cette API est meilleure, mais c'est juste.
L'API utilise un mécanisme de rappel pour informer les nouvelles données du programmeur. C'est aussi une bonne idée d'apprendre ce mécanisme, plutôt que de compter sur le port d'enquête. Contrairement à d'autres interfaces de rappel dans Java (telles que: dans l'interface graphique), cette interface permet à un seul moniteur d'écouter. Si plusieurs auditeurs demandent quelques incidents, le principal dispositif de surveillance doit être implémenté en distribuant des informations à d'autres auditeurs secondaires.
Téléchargement et installation
télécharger
La page Web Javacomm de Sun pointe vers l'adresse de téléchargement. Selon cette adresse, Sun actuellement (2007) fournit la version Javacom 3.0 qui prend en charge Solaris / SPARC, Solaris / x86 a déjà Linux x86. Les téléchargements nécessitent le compte d'une entreprise solaire. La page de téléchargement fournit un lien vers la page d'inscription. Le but de l'inscription n'est pas clair. Lors de l'inscription, les utilisateurs peuvent télécharger JDK et JRES, mais pour ces Javacomm presque triviaux, Sun Company a cité les dispositions légales et les restrictions gouvernementales sur la distribution et les exportations de logiciels.
Le responsable ne fournit plus la version Windows de Javacomm, et Sun a violé sa propre stratégie de mort de produits - Cannot être téléchargé dans Java Products. Mais vous pouvez toujours télécharger la version Windows de 2.0 à partir de cela (Javacom 2.0).
Installer
Installation avec les instructions d'installation avec téléchargement. Certaines versions de Javacomm 2.0 comprendront deux instructions d'installation. La différence la plus évidente entre ces deux descriptions est que le mauvais est utilisé dans l'ancien environnement Java1.1, et celui adapté à Java 1.2 (JDK1.2.html) est correct.
Les utilisateurs de Windows peuvent ne pas se rendre compte qu'ils ont installé la copie de la même machine virtuelle à différents endroits (généralement 3 à 4). Certaines applications IDE et Java peuvent également apporter leur propre JRE / JDK privé. Par conséquent, Javacomm doit être installé à plusieurs reprises sur ces machines virtuelles (JDK et JRE) afin de développer et d'exécuter des applications série.
IDE a un moyen IDE représentatif d'apprendre une nouvelle bibliothèque (classe et document). Habituellement, une bibliothèque que Javacomm doit non seulement être identifiée par l'IDE, mais également chaque projet utilisant la bibliothèque doit également être identifié. En lisant le document IDE, vous devez prêter attention à l'ancienne version de l'ancien Javacomm 2.0 et de la documentation de l'API Javadoc Utilisez la disposition Java 1.0 Java Doc. Certains IDE modernes ne connaissent plus ces structures et ne peuvent pas intégrer les documents Javacomm2.0 dans leurs systèmes d'aide. Dans ce cas, un navigateur externe est nécessaire pour lire des documents (activités recommandées)
Une fois le logiciel installé, il est recommandé de tester les échantillons et le répertoire Javadoc. Il est logique de créer et d'exécuter des exemples d'applications pour confirmer si l'installation est correcte. L'exemple de programme nécessite généralement quelques petits ajustements pour s'exécuter sur une plate-forme spéciale (comme l'identifiant de port com qui a réécrit les codes durs). Lors de l'exécution d'un échantillon de programme, il est préférable d'avoir du matériel en série.
Serial_Programming: RS-232 Connexions et Serial_Programming: modems et AT ATRORSS Fournit quelques informations sur la façon de créer un environnement de développement d'applications série.
Trouvez le port série attendu
Les trois premières choses à faire lors de l'utilisation de la programmation en série Javacomm
Le logo portuaire des attentes d'énumération et de sélection est terminé dans le même cycle:
Importer javax.comm. *; Comme "com1" ... "comx" aussi, et non // par leurs noms de périphériques Unix "/ dev / tty ...". Créez plutôt que l'utilisateur Configurable.//String WantportName = "/ dev / ttya"; Identifier si // (a) Il indique un port série (pas parallèle), et // (b) correspond au nom de conception.//commorditifier portID = null; CommptionIdifier PID = (CommptionIdifier) PortABLentifiers.NextElement (); ) {System.err.println ("n'a pas trouvé de port série" + WANDPORTNAME); Liste de logo série accessible par défaut dans le pilote lié à une plate-forme spécifique liée. Cette liste ne peut pas être configurée via Javacomm. Méthodes commptidifier.addportName () sont trompeuses, car la classe de pilote est liée à la plate-forme, et leur implémentation ne fait pas partie de l'API publique. S'appuyant sur le pilote, cette liste de ports peut être configurée / étendue dans le pilote. Par conséquent, si Javacomm ne trouve pas un certain port, certaines modifications apportées au conducteur aideront parfois. Une fois qu'un certain identifiant de port est trouvé, vous pouvez l'utiliser pour obtenir le port attendu: /////////////////////////// 0 Utiliser l'identifiant du port pour le compte // Serialport Port = null; Try {port = (serverport) portID.Open (nom ", // Nom de l'application demandant le port 10000 // attendre max. 10 sec. Pour acquérir le port); E); Système.
Port série d'initialisation
L'initialisation du port série est très intuitive. Vous pouvez définir les paramètres de communication (taux de potier, bit de données, bit d'arrêt et vérification des marionnettes) un par un.
Dans le cadre de l'initialisation, le flux de communication d'entrée et de sortie peut être configuré dans l'exemple suivant.
Importer java.io. *; ... //// / Définissez tous les paramètres. ; null; Tenput Stream: Write- Uniquement "); Nouveaux systèmes Linux Rappant Unicode, il peut donc être nécessaire de spécifier le schéma de codage à utiliser.), Ou ISO Latin 1 (8 bits // communication), car il n'y a probablement pas Modèle en accitant // Unicode pour son engagement. Se produire ici // PerformReadWriteCode (); Port.
Transmission de données simples écrivez simplement des données
L'écriture des données dans le port série est aussi simple que le Java IO de base. Mais il y a encore des précautions lorsque vous utilisez le protocole AT Hayes:
Presse-papiers
Faire:
Expliquez comment mélanger l'entrée et la sortie de binaires et de caractères dans le même flux
Modifiez l'échantillon de programme pour utiliser le flux
// Écrivez à la sortie os.print ("at"); os.print ("/ r / n"); Commande que vous y avez envoyé.Lecture de données simple (rotation)
Si vous utilisez correctement l'opération d'écriture (comme décrit ci-dessus), vous n'avez besoin que d'une commande simple.
// Lire la réponse ResponseString = Is.Readline ();
Questions de lecture et d'écriture simples
La simple lecture et écriture en série démontrée dans la section précédente présente des défauts très graves. Toutes les opérations sont effectuées en bloquant les E / S. Cela signifie que lorsqu'il n'y a pas de données lisibles ou que le tampon de sortie est plein (l'appareil ne peut pas accepter plus de données):
La méthode de lecture et d'écriture (dans l'exemple précédent est OS.print () ou is.readline ()) ne reviendra pas, ce qui entraînera la suspension de l'application. Plus précisément, les fils de lecture et d'écriture sont bloqués. Si ce thread est le thread principal de l'application, l'application s'arrêtera jusqu'à ce que les conditions de blocage soient publiées (c'est-à-dire les données lisibles à atteindre ou que l'appareil soit remis).
À moins que l'application ne soit la plus primitive, le programme est bloqué. Par exemple, au moins, il doit permettre aux utilisateurs d'annuler les opérations de communication. Cela nécessite l'utilisation d'E / S non bloquantes ou d'E / S asynchrones. Cependant, Javacomm est basé sur le système d'E / S standard (InputStream, OutputStream), mais il peut utiliser une technique de déformation affichée plus tard.
La «technique de déformation» de So-Salled est un support limité fourni par le Javacomm aux E / S asynchrones par le mécanisme de notification des incidents. Cependant, les solutions courantes pour réaliser des E / S non bloquantes en Java pour bloquer les E / S sont des threads. Cette solution pour le fonctionnement de la rédaction du port série est pratique et réalisable.
Les opérations de lecture doivent également être traitées dans un thread séparé, mais il n'est pas nécessaire d'utiliser le mécanisme de notification des incidents Javacomm. Résumer:
Lire l'opération et utiliser la notification des événements et / ou le thread séparé;
Utilisez des threads séparés pour écrire des opérations et le mécanisme de notification de l'événement peut être sélectionné.
La partie suivante présentera d'autres détails.
Événement Drive Communication en série Introduction
L'API Javacomm fournit un mécanisme de notification d'événement pour surmonter les problèmes causés par le blocage des E / S. Mais ce mécanisme est également problématique dans cette méthode du soleil typique.
En principe, une demande peut enregistrer un moniteur d'événements à un port série spécifique pour recevoir des notifications pour recevoir des événements importants sur ce port. Les deux événements les plus intéressants de données de lecture et d'écriture sont
javax.comm.serialportEvent.data_available et javax.comm.serialportEvent.output_buffer_empty.
Mais cela apporte également deux questions:
Avant de mener des discussions détaillées, la section suivante démontrera la principale méthode de mise en œuvre et d'enregistrement d'un processeur d'événements en série. N'oubliez pas qu'il n'y a qu'un seul processeur d'événements dans un port série et qu'il doit faire face à tous les événements possibles.
Définir le processeur d'événements série
Importer Javax.comm. Informations * sur la communication, par exemple, une communication particulière * doit être suivie. Méthode. Event.getEventType ()) {Case serialportEvent.output_empty: outputBufelempty (événement); Le case SerialportEvent. Break; case SerialportEvent. / ** * Gire les événements vides du tampon de sortie. / Implémentez les données WU ici} / ** * Gire les données des données disponibles. Une fois l'auditeur implémenté, il peut être utilisé pour surveiller des incidents en série spécifiques. Pour ce faire, vous devez ajouter une instance d'écoute du port série. De plus, la réception de chaque type d'événement nécessite des applications distinctes.
Port Serialport = ...; ... /// Configurez les paramètres du port ici. Images L'interface ServiceTListener // on appelle ///port.addeventRistERner (ceci); E); ;
Rédaction de données
L'écriture de données avec une séparation séparée n'est qu'un seul objectif: éviter l'ensemble du bloc d'application verrouillé car un port série n'est pas prêt à rédiger des données.
Une réalisation de tampon d'anneau simple et usafée
Utilisez un thread indépendant de la ligne principale pour écrire des opérations, indiquant que les données qui doivent être écrites d'une manière ou d'une autre sont soumises au thread d'écriture à partir du thread d'application principal (thread principal). Cela peut utiliser un tampon d'événements asynchrones partagé, comme un tableau d'octets. De plus, le programme principal a également besoin d'un moyen de déterminer si les données ou le tampon de données peuvent être écrits dans le tampon de données. Si le tampon de données est plein, il indique que le port série n'est pas prêt à rédiger des opérations et que les données à sortie sont en file d'attente. Le programme principal doit demander un nouvel espace libre disponible dans le tampon de données partagé. Cependant, dans l'écart entre le programme principal, vous pouvez faire d'autres choses, telles que la mise à jour de l'interface utilisateur (GUI), fournissant une invite de commande qui peut quitter les données, etc.
À première vue, PipedInputStream / PipedOutputStream est une bonne idée pour cette communication. Mais si le flux du pipeline est vraiment utile, alors le soleil n'est pas le soleil. Si le PipEdoutStream correspondant n'est pas nettoyé dans le temps, PipedInputStream bloquera, ce qui bloquera le thread d'application. Même si vous utilisez des fils indépendants, vous ne pouvez pas l'éviter. Java.nio.pipe a également le même problème que celui-ci. Son obstruction est liée à la plate-forme. Il n'est pas très bon de changer les E / S traditionnelles en utilisant Javacomm à Nio.
Une zone de tampon d'anneau synchrone très simple est utilisée dans cet article pour la transmission des données de thread. Les applications dans le monde réel sont susceptibles d'utiliser un tampon plus complexe. Par exemple, la réalisation d'un monde réel nécessite un tampon d'opération du point de vue de l'entrée et du flux de sortie.
Un tel tampon d'anneau n'est pas spécial et il n'y a pas d'attribut spécial dans le traitement des threads. Il s'agit simplement d'une structure de données simple utilisée ici pour fournir un tampon de données. Le tampon a été mis en œuvre ici pour s'assurer que l'accès à la structure de données est la sécurité du thread.
/ *** Tampon de Rauning synchronisé. * Convient à la main sur un thread à un autre. ** Taille du tampon ** / Taille INT protégée; Taille de 1k. Clear ();} / ** * Effacer le contenu du tampon. être écrasé pendant le fonctionnement normal. , Il n'est pas valide à côté lorsque les données sont lues à partir du * tampon ou écrivez le tampon. Int Data () {return start <= end? . Données comme possible. Param Array Holding Data à écrire * @param off officiel de données dans le tableau * @param n Montant de données à écrire, à partir de. int n) {if (n <= 0) Retour 0; int restent = n; -END); end> = start? / ** * Lire autant de données que possible à partir du tampon. );} / ** * Lisez autant de données que possible à partir du tampon. / int lic (data byte [], int bureau de bureau: 0 = <= off <data.length; lancez l'exception si non int i = math.min (reste, (end <start? tamper.length: end) -start) ; ;} i = math.min (restez, end> = start? 0: end); ;} Retour n -remain;}}}}}En utilisant ce tampon d'anneau, vous pouvez désormais soumettre des données d'un thread à un autre thread. Bien sûr, les autres fils sont des méthodes sûres et non bloquantes. Le point clé ici est que lorsque le tampon est plein ou que le tampon est vide, la lecture et l'écriture des données ne provoqueront pas de blocage.
Selon le contour de la démonstration du processeur d'événements de la démonstration de la section dans le "Créer un processeur d'entreprise en série", vous pouvez utiliser le tampon d'anneau partagé introduit dans le "tampon d'anneau de filetage simple" pour prendre en charge l'événement Output_Buffer_Empty. Toute la mise en œuvre de Javacomm prend en charge cet événement, donc ce code peut ne jamais être appelé. Mais si cela le peut, cela fait partie de la garantie du meilleur débit de données, car il peut faire du port série dans un état d'oisiveté pendant longtemps.
Le contour du moniteur d'événements doit fournir une méthode OutputBuffRempty ().
Ringbuffer databuffer = ...; OutputBuff sur (SerialPortEvent Event) {}L'exemple suivant suppose que la destination des données est un fichier. Lorsque les données arrivent, elles seront supprimées du port série et écrites dans le fichier de destination. Il s'agit simplement d'une vue raffinée, car en fait, vous devez vérifier le logo EOF des données pour réguler le modem (généralement appelé "chat") comme mode de commande.
Importer javax.comm. *; ... InputStream est = port.getInputStream (); ** * Gérer l'événement série. SerialportEvent.data_available: // // Déplacez toutes les données actuellement disponibles dans le fichier // essai {int c; Catch (ioException ex) {...} Break; );}
Modifier le contrôle du démodulateur
Javacomm est principalement préoccupé par un traitement en série et une transmission des données sur le port série. Il ne comprend pas ou ne prend pas en charge les protocoles de haut niveau, tels que les instructions de modulation et de démolation de Hayes est généralement utilisé pour contrôler les chats de niveau client. Ce n'est pas la tâche de Javacomm, ni un bug.
Comme d'autres dispositifs de série spéciaux, si vous souhaitez contrôler un chat avec Javacomm, vous devez écrire le code nécessaire sur Javacomm. La page "Hayes-Commose Modems et AT AT AT" fournit les informations de base nécessaires pour traiter les chats Hayes.
Certains systèmes d'exploitation, comme Windows ou une commande de contrôle Linux pour configurer un type spécial ou une marque de commandes de contrôle CAT, fournissent des normes plus ou moins. Par exemple, le "pilote" des chats Windows n'est généralement que des entrées enregistrées, décrivant des chats individuels (le véritable pilote est un pilote de modulation en série universel). Javacomm ne peut pas obtenir de données spécifiques de ces systèmes d'exploitation. Par conséquent, un outil Java distinct doit être fourni pour permettre aux utilisateurs de configurer une application d'utilisation des chats individuels, soit ajouter un code de plate-forme (local) correspondant.
Rxtx
Aperçu et version
Étant donné que Sun n'a pas fourni de mise en œuvre de référence Javacomm pour Linux, les gens ont développé RXTX pour Java et Linux. Plus tard, RXTX a été transplanté sur d'autres plates-formes. La dernière version de RXTX est connue pour exécuter plus de 100 plates-formes, notamment Linux, Windows, Mac OS, Solaris et d'autres systèmes d'exploitation.
RXTX peut être utilisé indépendamment de l'API Javacomm, ou il peut également être utilisé comme un service API Java Commum So-appelé. Si ce dernier utilise un package d'emballage appelé JCL. JCL et RXTX sont généralement remplis de Linux / Java, ou JCL est complètement intégré au code. Par conséquent, avant de les télécharger un par un, jetez un œil au CD de la version Linux Distribution du CD.
En raison du soutien limité de Sun et de la documentation inappropriée de Javacomm, il a abandonné l'API Javacomm et s'est tourné directement pour utiliser RXTX au lieu du package JCL. Cependant, les documents de RXTX sont très rares. En particulier, les développeurs RXTX aiment faire de leurs versions et du contenu du sac un gâchis (comme l'utilisation ou JCL intégrée inutilisée). À partir de la version 1.5, RXTX comprend une classe alternative de la classe publique Javacomm. Pour des raisons juridiques, ils n'étaient pas dans le package java.pomm, mais sous Gui.io. Cependant, les deux version existante du contenu d'emballage sont très différentes.
Par conséquent, si vous souhaitez programmer l'API Javacomm d'origine
Sun Javacomm General Edition. Lors de la rédaction de cet article est en fait le package UNIX (y compris la prise en charge de divers types de systèmes UNIX, comme Linux ou Solaris), même sur Windows, ce package UNIX doit également être utilisé pour fournir une implémentation universelle de java.comm. Utiliser uniquement Java pour implémenter cette partie sera utilisé, mais la bibliothèque locale d'Unix sera ignorée.
RXTX 2.0, afin d'avoir différents fournisseurs dans la version universelle du Javacomm, contrairement à celui du package Javacomm. Cependant, si vous souhaitez simplement remplacer le package par GNU.IO, vous n'avez qu'à convertir une application Javacomm en une application RXTX.
Si vous abandonnez l'un des nombreux membres des nombreux membres qui font que Javacomm déçoit du comportement des fenêtres de support, vous devez transférer votre Javacomm vers RXTX. Comme vous pouvez le voir ci-dessus, il existe deux façons de terminer cela.
上面的第一项在前面已经解释，第二项也相当简单。对于需要将JavaComm应用移植到RxTx 2.1上来的人，只需要将应用源代码中所有对“java.comm”包的引用换成“gnu.io”包，如果原始的JavaComm应用编写恰当，这里就没有其他的事情需要去做。
在Unix平台上，RxTx 2.1甚至提供了工具“contrib/ChangePackage.sh”去在源代码树形结构中执行全局的替换，这样的替换在其他的平台很容易使用支持重构功能的IDE（集成开发环境）来完成。