Problema comum
Javacomm e RXTX têm coisas diferentes ao instalar. É altamente recomendável instalar um pouco de instalação de acordo com as instruções de instalação. Se as instruções de instalação exigirem um arquivo JAR ou uma biblioteca compartilhada deverá estar em uma pasta específica, o que significa que ela precisa ser levada a sério. Se um arquivo ou dispositivo específico precisar ter uma propriedade ou acesso específico, isso também significa que ele precisa ser tratado seriamente. Muitos problemas de instalação são causados por não de acordo com os requisitos das instruções de instalação.
Deve -se notar que algumas versões do Javacomm terão duas instruções de instalação. Um é usado para Java 1.2 e, posterior, um para a versão Java 1.1. Usando as instruções de instalação erradas causará o resultado da instalação que não pode ser trabalhado. Por outro lado, algumas versões/componentes/pacotes do TXTX conterão descrições incompletas. Nesse caso, é necessário obter o código -fonte publicado pelo RXTX, que contém instruções completas de instalação.
Além disso, deve -se notar que o programa de instalação do JDK do Windows conterá três máquinas virtuais Java, para que haja três pastas estendidas.
Além do mais, até o quarto JRE, que existe na estrutura de diretórios do/Windows. O Javacomm deve ser instalado no JDK e em todos os JRE público como extensões.
Webstart
Javacomm
Um problema comum sobre o Javacomm e o RXTX é que eles não suportam a instalação através do Java Webstart: o Javacomm's Infamous é porque você precisa ligar para um arquivo chamado javax.com.properties para o diretório JDK Lib, e isso não pode ser via Java Webstart concluído. É muito frustrante que a necessidade desse arquivo seja alguns designs desnecessários em Javacomm, e os designers do Javacomm possam facilmente evitar isso. Sun teimosamente rejeitou o erro e enfatizou que esse mecanismo é essencial. Eles estavam falando bobagem, especialmente quando mencionaram Javacomm, porque Java tinha uma arquitetura de provedor de serviços especializada em tais intenções por um longo tempo.
Existe apenas uma linha no conteúdo deste arquivo de atributo, que fornece um nome de classe Java, acionado local.
driver = com.sun.win.win32driver
A seguir, é apresentada uma técnica que pode implantar o Javacomm por meio da Web começar a ignorar o arquivo de atributo que prejudica o cérebro. Mas tem defeitos graves e pode falhar ao implantar um Javacomm -mais recente -se a Sun formar uma nova versão.
Primeiro, desligue o gerente de segurança. Alguns programadores estúpidos do Sol sentiram que a existência dos terríveis arquivos Javax.Comm.Properties era legal repetidamente, especialmente depois de ser carregada pela primeira vez. Isso apenas verifica se o arquivo existe sem outros motivos.
System.SetSecurityManager (NULL);
Então, quando a API do Javacomm foi originalmente iniciada originalmente, inicializou manualmente o motorista.
String drivename = "com.sun.comm.win32driver";
Rxtx
O RXTX precisa alterar a propriedade e o acesso ao direito do dispositivo serial em algumas plataformas. Isso também é algo que não pode ser feito através do Webstart.
Quando o programa é iniciado, você deve solicitar aos usuários que executem as configurações necessárias como super usuários. Em particular, o RXTX possui um algoritmo de correspondência de modo para verificar o nome do equipamento serial "legal". Quando alguém quer usar dispositivos não padrão, como o conversor USB-Série, isso muitas vezes atrapalha as coisas. Esse mecanismo pode ser bloqueado pelos atributos do sistema. Para detalhes, consulte as instruções de instalação do RXTX.
Javacomm API
introdução
A API oficial de comunicação em série de Java é a API Javacomm. Esta API não faz parte da versão padrão do Java 2; portanto, a implementação desta API precisa ser baixada separadamente. Infelizmente, Javacomm não recebeu atenção suficiente ao sol, e o tempo de manutenção real não foi muito longo. Sun apenas reparou alguns insetos sem importância ocasionalmente, mas não fez uma manutenção importante que expirou há muito tempo.
Esta seção explica a operação básica da API Javacomm. O código -fonte fornecido é simplificado para exibir o foco e precisa ser aprimorado em aplicações práticas.
O código -fonte deste capítulo não é o único código de exemplo disponível. Muitos exemplos contêm downloads de javacomm. Esses exemplos incluem mais informações sobre como usá -las do que seus documentos da API. Infelizmente, o Sun não tem tutorial real ou alguns documentos de explicação. Portanto, para entender o mecanismo dessa API, vale a pena aprender esses exemplos e você ainda precisa aprender esse documento da API. Mas a melhor maneira é aprender esses exemplos e usá -los. Devido à falta de aplicações fáceis de uso e compreensão do modelo de programação dessas APIs, as APIs geralmente são atacadas. Comparado à sua reputação e função, essa API é melhor, mas isso é apenas.
A API usa um mecanismo de retorno de chamada para notificar os novos dados do programador. Também é uma boa idéia aprender esse mecanismo, em vez de confiar na porta de consulta. Ao contrário de outras interfaces de retorno de chamada em Java (como: na interface gráfica), essa interface permite que apenas um monitor ouça. Se vários ouvintes solicitarem alguns incidentes, o principal dispositivo de monitoramento deverá ser implementado distribuindo informações para outros ouvintes secundários.
Download e instalação
download
A página da web do Javacomm da Sun aponta para o endereço de download. Sob este endereço, a Sun Atualmente (2007) fornece a versão Javacom 3.0 que suporta Solaris/Sparc, Solaris/X86 já possui o Linux X86. Downloads requer uma conta de uma empresa solar. A página de download fornece um link para a página de registro. O objetivo do registro não é claro. Ao se registrar, os usuários podem baixar o JDK e o JRES, mas para esses Javacomm quase triviais, a Sun Company citou disposições legais e restrições governamentais na distribuição e exportação de software.
O funcionário não fornece mais a versão do Windows do Javacomm, e a Sun violou sua própria estratégia de morte de produto -o canalh é baixado nos produtos Java. Mas você ainda pode baixar a versão do Windows do 2.0 deste (Javacom 2.0).
Instalar
Instalação com as instruções de instalação com download. Algumas versões do Javacomm 2.0 incluirão duas instruções de instalação. A diferença mais óbvia entre essas duas descrições é que a errada é usada no ambiente Java1.1 antigo, e a adequada para Java 1.2 (JDK1.2.html) está correta.
Os usuários do Windows podem não perceber que instalaram a cópia da mesma VM em locais diferentes (geralmente 3 a 4). Alguns aplicativos IDE e Java também podem trazer seu próprio JRE/JDK particular. Portanto, o Javacomm precisa ser instalado repetidamente nessas VM (JDK e JRE) para que para desenvolver e executar aplicativos seriais.
O IDE possui uma maneira representativa do IDE de aprender uma nova biblioteca (classe e documento). Geralmente, uma biblioteca que o Javacomm não apenas precisa ser identificada pelo IDE, mas também cada projeto usando a biblioteca também deve ser identificado. Lendo o documento IDE, você deve prestar atenção à versão antiga do antigo Javacomm 2.0 e a documentação da API Javadoc use o layout Java 1.0 Java Doc. Alguns IDEs modernos não conhecem mais essas estruturas e não podem integrar documentos Javacomm2.0 em seus sistemas de ajuda. Nesse caso, é necessário um navegador externo para ler documentos (atividades recomendadas)
Depois que o software é instalado, é recomendável testar amostras e diretório Javadoc. Faz sentido criar e executar aplicativos de amostra para confirmar se a instalação está correta. O programa de amostra geralmente requer alguns pequenos ajustes para executar em uma plataforma especial (como o identificador de porta COM que reescreveu os códigos rígidos). Ao executar um programa de amostra, é melhor ter algum hardware serial.
Serial_programming: conexões RS-232 e Serial_programming: Modems and AT Commands fornece algumas informações sobre como criar um ambiente de desenvolvimento de aplicativos em série.
Encontre a porta serial esperada
As três primeiras coisas a serem feitas ao usar a programação serial javacom
O logotipo da porta das expectativas de enumeração e seleção é concluído no mesmo ciclo:
Importar javax.comm.*; Como "com1" ... "comx" também, e não // pelos nomes dos dispositivos UNIX "/dev/tty ...". Em vez disso, faça o usuário configurável.//String WantedPortName = "/dev/ttya"; Identificador se // (a) Indica uma porta serial (não paralela) e // (b) corresponde ao nome do design./CommportIdentifier PortID = null; CommptionIdIcier PID = (CommptionIdIcier) PortablEntifiers.NextElement (); ) {System.err.println ("Não foi possível encontrar porta serial" + WantedPortName); Lista de logotipo serial acessível padrão no driver relacionado a uma plataforma específica que está vinculada. Esta lista não pode realmente ser configurada através do Javacomm. Os métodos comandpidifier.addportName () são enganosos, porque a classe de motorista está relacionada à plataforma e sua implementação não faz parte da API pública. Contando no driver, esta lista de portas pode ser configurada/estendida no driver. Portanto, se Javacomm não encontrar uma certa porta, algumas alterações no motorista às vezes ajudam. Depois que um determinado identificador de porta é encontrado, você pode usá -lo para obter a porta esperada: //////////////////////////// 0 Use a porta Identifier Para conta // porta serialport = null; e);
Porta serial de inicialização
A inicialização da porta serial é muito intuitiva. Você pode definir os parâmetros de comunicação (taxa de potter, bit de dados, bit de parada e verificação de bonecos) um por um.
Como parte da inicialização, o fluxo de comunicação de entrada e saída pode ser configurado no exemplo a seguir.
Importar java.io.*; ; NULL; Denput Stream: Write- Somente "); novos sistemas Linux que dependem do Unicode, por isso pode ser necessária para // especificar o esquema de codificação a ser usado.) Ou ISO Latin 1 (8 bits // Comunicação), pois provavelmente não há não Modelo lá fora Aceitando // unicode para seu compromisso. Acontece aqui // PerformReadWriteCode (); Porto.
Transmissão de dados simples simplesmente escreve dados
Escrever os dados na porta serial é tão simples quanto o java básico IO. Mas ainda existem algumas precauções quando você usa o protocolo AT Hayes:
Praça de transferência
Pendência:
Explique como misturar a entrada e saída de binários e caracteres no mesmo fluxo
Modifique o programa de amostra para usar o fluxo
// grava no OS.PRINT ("AT"); OS.PRINT ("/R/N"); Comando que você enviou para ele.Leitura de dados simples (rotação)
Se você usar a operação de escrita corretamente (como descrito acima), você só precisará de um comando simples.
// Leia a resposta Responsestring = is.readline ();
Perguntas simples de leitura e escrita
A leitura e a escrita em série simples demonstradas na seção anterior têm defeitos muito graves. Todas as operações são feitas bloqueando a E/S. Isso significa que quando não há dados legíveis ou o buffer de saída está cheio (o dispositivo não pode aceitar mais dados):
O método de leitura e escrita (no exemplo anterior é OS.print () ou is.readline ()) não retornará, fazendo com que o aplicativo seja suspenso. Mais precisamente, os tópicos de leitura e escrita estão bloqueados. Se esse thread for o encadeamento principal do aplicativo, o aplicativo parará até que as condições de bloqueio sejam liberadas (ou seja, dados legíveis para alcançar ou o dispositivo será receptivo).
A menos que o aplicativo seja o mais primitivo, o programa está bloqueado. Por exemplo, pelo menos ele deve permitir que os usuários cancelem as operações de comunicação. Isso requer o uso de E/S não bloqueadora ou E/S assíncrona. No entanto, o Javacomm é baseado no sistema de E/S padrão (InputStream, OutputStream), mas pode usar uma técnica de deformação exibida posteriormente.
A "Técnica de deformação" de So So é um suporte limitado fornecido pelo Javacomm à E/S assíncrona através do mecanismo de notificação de incidentes. No entanto, as soluções comuns para realizar a E/S não bloqueadora em Java para bloquear a E/S são threads. Esta solução para a operação de escrita em série é prática e viável.
As operações de leitura também devem ser processadas em um encadeamento separado, mas não é necessário usar o mecanismo de notificação de incidentes do Javacomm. Resumir:
Leia a operação e use notificação de eventos e/ou encadeamento separado;
Use threads separados para gravar operações e o mecanismo de notificação de eventos pode ser selecionado.
A próxima parte apresentará alguns outros detalhes.
Introdução de comunicação serial de acionamento de eventos
A API Javacomm fornece um mecanismo de notificação de eventos para superar os problemas causados pelo bloqueio da E/S. Mas esse mecanismo também é problemático neste método típico do sol.
Em princípio, um aplicativo pode registrar um monitor de eventos em uma porta serial específica para receber notificações para receber eventos importantes nesta porta. Os dois eventos mais interessantes de leitura e escrita de dados são
javax.comm.serialportEvent.data_available e javax.comm.serialportEvent.output_buffer_empty.
Mas isso também traz duas perguntas:
Antes de realizar discussões detalhadas, a próxima seção demonstrará o principal método de implementação e registro de um processador de eventos em série. Lembre -se de que existe apenas um processador de eventos em uma porta serial e ele precisa lidar com todos os eventos possíveis.
Defina o processador de eventos em série
Importar Javax.Comm. Informações * sobre a comunicação, por exemplo, quando um protocolo de comunicação * precisa ser seguido. Método. Event.GeteventType ()) {Case SerialportEvent.Output_Empty: O outputBuMepty (Evento); Break; Break; / ** * Handle Buffer de saída Eventos vazios. / Implementar dados wu aqui}/ ** * Lidar com os dados disponíveis. Depois que o ouvinte é implementado, ele pode ser usado para monitorar incidentes seriais específicos. Para fazer isso, você precisa adicionar uma instância para ouvir a porta serial. Além disso, o recebimento de cada tipo de evento requer aplicativos separados.
Porta serialport = ...; Imagens A interface ServiceEventListener // One LIGADO //PORTE. e); ;
Escrita de dados
A escrita de dados com separação separada é apenas um objetivo: evitar o bloqueio de todo o bloco de aplicativos porque uma porta serial não está pronta para gravar dados.
Uma realização simples de tampão de anel de threads e threads
Use um thread independente da linha de programa principal para escrever operações, indicando que os dados que precisam ser gravados de alguma maneira são enviados ao tópico de escrita do thread principal do aplicativo (thread principal). Isso pode usar um buffer de eventos assíncronos compartilhados, como uma matriz de bytes. Além disso, o programa principal também precisa de alguma maneira de determinar se os dados ou o buffer de dados podem ser gravados no buffer de dados. Se o buffer de dados estiver cheio, indica que a porta serial não está pronta para escrever operações e os dados a serem emitidos estão na fila. O programa principal precisa perguntar um novo espaço livre disponível no buffer de dados compartilhado. No entanto, na lacuna entre o programa principal, você pode fazer outras coisas, como atualizar a interface do usuário (GUI), fornecendo um prompt de comando que pode sair de dados e assim por diante.
À primeira vista, o PipedInputStream/PipedOutputStream é uma boa ideia para esta comunicação. Mas se o fluxo do oleoduto for realmente útil, o sol não é o sol. Se o pipedStream correspondente não for limpo a tempo, o PipedInputStream bloqueará, o que bloqueará o encadeamento do aplicativo. Mesmo se você usar tópicos independentes, não pode evitá -lo. Java.nio.pipe também tem o mesmo problema que este. Sua obstrução está relacionada à plataforma. Não é muito bom mudar a E/S tradicional usando o Javacomm para Nio.
Uma área de tampão síncrona muito simples é usada neste artigo para transmissão de dados de threads. As aplicações no mundo real provavelmente usarão buffer mais complexo. Por exemplo, a realização de um mundo real exige um buffer de operação da perspectiva do fluxo de entrada e saída.
Esse buffer de anel não é especial e não há atributo especial no processamento de threads. É apenas uma estrutura de dados simples usada aqui para fornecer buffer de dados. O buffer foi implementado aqui para garantir que o acesso à estrutura de dados seja a segurança do thread.
/*** Buffer de Raing sincronizado. ** Tamanho do buffer ** / Tamanho INT protegido; Tamanho de 1k. Clear ();} / ** * Limpe o conteúdo do buffer. ser substituído durante a operação normal. , Ele não é válido quando os dados são lidos no buffer ou gravar o buffer. Int Data () {Retorno Iniciar <= END? . Dados como posses. Param Data Array mantendo dados a serem escritos * @param off Office of Data in ARRAY * @param n Quantidade de dados para gravar, começando. , int n) {if (n <= 0) Retorno 0; ) - END); , final> = Iniciar: 0); } / ** * Leia os dados do Buffer. Comprimento);} /** * Leia o máximo de dados do Buffer. */ int read (byte dados [], int Office tampa: 0 = <= off <data.length; lança exceção se não int i = math.min (permaneça, (end <start? buffer.length: end) -start ); 0;} i = matemática.Min (permanecendo, final> = start? 0: end); i;} retornar n -remain;}}}}}Ao usar este buffer de anel, agora você pode enviar dados de um thread para outro. Obviamente, outros threads são métodos seguros e não bloqueadores. O ponto principal aqui é que, quando o buffer está cheio ou o buffer está vazio, a leitura e a gravação dos dados não causam bloqueio.
De acordo com o esboço da demonstração do processador de eventos da demonstração da seção no "Criar processador serial empresarial", você pode usar o buffer de anel compartilhado introduzido no "buffer de anel segura de thread simples" para suportar o evento OUTPT_BUFFER_EMPTY. Nem toda a implementação do Javacomm suporta este evento, portanto, esse código pode nunca ser chamado. Mas, se puder, faz parte de garantir a melhor taxa de transferência de dados, porque pode fazer a porta serial em um estado de ociosidade por um longo tempo.
O esboço do monitor de eventos precisa fornecer um método de saída de outputBuffRepty ().
RingBuffer Databuffer = ...; outputBuff ON (Evento SerialportEvent) {}O exemplo a seguir assume que o destino dos dados é um arquivo. Quando os dados chegarem, eles serão removidos da porta serial e gravados no arquivo de destino. Esta é apenas uma visualização refinada, porque na verdade você precisa verificar o logotipo EOF dos dados para regular o modem (geralmente chamado de "gato") como o modo de comando.
Importar javax.comm. *; ** * Evento serial de manipulação. SerialPortEvent.data_available: // // Mova todos os dados disponíveis para o arquivo // tente {int c; Catch (ioexception ex) {...} Break; );}
Modificar o controle do desmodulador
Javacomm está preocupado principalmente com um processamento e transmissão em série de dados na porta serial. Ele não entende ou fornece suporte para protocolos de alto nível, como a modulação e as instruções de desmodulação Hayes geralmente é usada para controlar os gatos no nível do cliente. Esta não é a tarefa de Javacomm, nem é um bug.
Como outros dispositivos seriais especiais, se você deseja controlar um gato com Javacomm, deve escrever o código necessário no Javacomm. A página "Modems de composição Hayes e comandos" fornece as informações básicas necessárias para processar os gatos Hayes.
Alguns sistemas operacionais, como Windows ou um comando Linux Control para configurar um tipo especial ou marca de comandos de controle de gatos, fornecem mais ou menos padrões. Por exemplo, o "driver" dos gatos do Windows geralmente é apenas entradas registradas, descrevendo gatos individuais (o driver real é um driver de modulação serial universal). O Javacomm não pode obter dados específicos de tais sistemas operacionais. Portanto, uma ferramenta Java separada deve ser fornecida para permitir que os usuários configurem um aplicativo para o uso de gatos individuais ou adicione algum código de plataforma correspondente (local).
Rxtx
Visão geral e versão
Como a Sun não forneceu a implementação de referência do Javacomm para o Linux, as pessoas desenvolveram o RXTX para Java e Linux. Mais tarde, o RXTX foi transplantado para outras plataformas. Sabe -se que a versão mais recente do RXTX executa mais de 100 plataformas, incluindo Linux, Windows, Mac OS, Solaris e outros sistemas operacionais.
O RXTX pode ser usado independentemente da API do Javacomm, ou também pode ser usado como um serviço de API de Java Commum chamado. Se este último usar um pacote de embalagem chamado JCL. JCL e RXTX geralmente são embalados com Linux/Java, ou JCL é completamente integrado ao código. Portanto, antes de baixá -los um por um, dê uma olhada no CD da versão de distribuição Linux do CD.
Devido ao suporte limitado da Sun e à documentação inadequada do Javacomm, ele abandonou a API Javacomm e virou diretamente para usar o RXTX em vez do pacote de embalagem da JCL. No entanto, os documentos da RXTX são muito raros. Em particular, os desenvolvedores do RXTX gostam de tornar suas versões e conteúdo de bolsas uma bagunça (como usar ou JCL integrado não utilizado). A partir da versão 1.5, o RXTX inclui uma classe alternativa da classe pública Javacomm. Por razões legais, eles não estavam no pacote Java.Pomm, mas sob Gui.io. No entanto, a versão existente do conteúdo da embalagem é muito diferente.
Portanto, se você deseja programar a API Javacomm original
Sun Javacomm Edição Geral. Ao escrever este artigo, na verdade, o pacote Unix (incluindo suporte para vários tipos de sistemas Unix, como Linux ou Solaris), mesmo no Windows, este pacote Unix também precisa ser usado para fornecer implementação universal de java.comm. Somente o uso do Java para implementar essa parte será usado, mas a biblioteca local da Unix será ignorada.
RXTX 2.0, para ter diferentes fornecedores na versão universal do Javacomm, ao contrário do do pacote Javacomm. No entanto, se você deseja apenas substituir o pacote pelo GNU.io, só precisará converter um aplicativo Javacomm em um aplicativo RXTX.
Se você desistir de um dos muitos membros de muitos membros que fazem Javacomm que decepcionou com o comportamento de apoiar o Windows, transfira seu Javacomm para o RXTX. Como você pode ver acima, há duas maneiras de concluir isso.
O primeiro item acima foi explicado anteriormente e o segundo item é bastante simples.对于需要将JavaComm应用移植到RxTx 2.1上来的人，只需要将应用源代码中所有对“java.comm”包的引用换成“gnu.io”包，如果原始的JavaComm应用编写恰当，这里就没有其他的事情需要去做。
在Unix平台上，RxTx 2.1甚至提供了工具“contrib/ChangePackage.sh”去在源代码树形结构中执行全局的替换，这样的替换在其他的平台很容易使用支持重构功能的IDE（集成开发环境）来完成。