Boa tarde aos colegas do forum!
Há exatamente 1 mes e 3 dias que estou aprendendo a lidar com essa maravilhosa linguagem de programação Java.
Agora na sequencia de meus estudos,gostaria de acessar as portas do pc(serial,paralela ou usb).
Andei pesquisando e verifiquei que a SUN(oracle)não tem muito interesse em se preocupar com essa interação entre software e hardware,estou correto no meu comentario ou é impressão?
Se alguém tiver alguma informação sobre algum material novo, pois tenho pesquisado e tem muitas informações antigas.
grato
Então, dependendo o que você quiser fazer, é mais fácil utilizar uma ponte com DLL’s do que fazer diretamente com java.
Mas para USB existe esse projeto http://jusb.sourceforge.net/
[]'s
Daniel
yorgan ,boa tarde
A principio ,acender um led na porta paralela(treinamento para aprimorar conhecimento)e partir para a serial lendo e escrevendo nas portas(automação e controle de cargas)
Tipo voce poder fazer mediçoes(leituras de sensores) e ao mesmo tempo ligar ou desligar alguma carga,um motor por exemplo.
O que voce quer dizer com fazer uma ponte com DLL,poderia me explicar?
valeu
Então.
Quando eu programava em VB, era tranquilo enviar um sinal para porta paralela e ficar brincando com leds.
Mas em java eu vi que a coisa não era tão simples.
Para trabalhar com essas coisas é mais comum fazer uma DLL que faça a comunicação com as portas e fazer o java comunicar com essa DLL.
Mas se for para trabalhar com eletrônica, eu acho melhor utilizar Arduino.
Desde que conheci essa solução, desisti de tentar fazer o Java conectar diretamente com essas portas.
[]'s
Daniel
É ,realmente voce tem razão,a dificuldade em comunicar com portas em java pelo jeito é geral…
mas,uma linguagem que faz um monte de coisas ,coloca voce mais proximo do real é estranho que tenha abandonado a ideia de comunicação com o mundo externo(hardware)
vamos ver se a Oracle pense diferente,enquanto isso vou tentando com o que tem de disponivel na internet.
acho que vou até mandar um email pra eles questionando sobre o assunto…
grato
Não sei, acho que esse tipo de comunicação é melhor deixar para linguagens nativas do sistema operacional.
O foco do java, ao meu ver, é outro.
Já o Arduino resolve esse problema. Tudo é escrito em C, mas tem todas as ferramentas para comunicação com Java, tanto que sua IDE foi feita em Java.
Já me falaram do arduino e até andei atras,o microcontrolador parece que é da Atmel,trabalho com os da microchip(PIC)tem um pessoal trabalhando na edição de um livro programação java pra pic.
não sei como eles colocaram algo parecido com a JVM lá dentro …
um abraço e obrigado por suas dicas…
Para mexer com portas seriais, procure por rxtxcomm.
Para comunicar com portas paralelas é mais simples.
Sabe aquelas impressoras de cupom não fiscal? (aquelas que fazem tátá tátátá o dia inteiro na orelha de um programador) Elas são conectadas atravez da porta paralela LPT. Se você criar uma porta LPT1 no Sisitema Operacional e conectar a impressora nessa porta, basta usar:
PrintWriter pw = new PrintWriter("LPT1");
pw.print("OI?")
pw.close();Vai sair “OI?” na sua impressora.
Agora basta intender o que o seu hardware precisa receber e passar.
Precisei trabalhar com um impressora de etiqueta com porta paralela, li a documentacao e a sintaxe dela, entao passei o que ela precisava.
Também ja precisei trabalhar com impressoras com memória fiscal na porta serial, sem dll do fabricante, mandando os dados direto para a porta (com auxilio de uma dll para conexao com a porta). Usei essa forma, estabeleco a conexao com a porta e “meto bala (bytes)”
Uma classe utilitária para porta serial.
[code]
import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.NoSuchPortException;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import gnu.io.UnsupportedCommOperationException;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.TooManyListenersException;
public class ComunicacaoSerial implements SerialPortEventListener {
public static int DATABITS_5 = SerialPort.DATABITS_5;
public static int DATABITS_6 = SerialPort.DATABITS_6;
public static int DATABITS_7 = SerialPort.DATABITS_7;
public static int DATABITS_8 = SerialPort.DATABITS_8;
public static int STOPBITS_1 = SerialPort.STOPBITS_1;
public static int STOPBITS_1_5 = SerialPort.STOPBITS_1_5;
public static int STOPBITS_2 = SerialPort.STOPBITS_2;
public static int PARIDADE_PAR = SerialPort.PARITY_EVEN;
public static int PARIDADE_NENHUMA = SerialPort.PARITY_NONE;
public static int PARIDADE_ESPACO = SerialPort.PARITY_SPACE;
public static int PARIDADE_IMPAR = SerialPort.PARITY_ODD;
public static int PARIDADE_SINAL = SerialPort.PARITY_MARK;
private SerialPort serialPort = null;
private InputStream entrada = null;
private OutputStream saida = null;
private static ComunicacaoSerial comunicacaoSerial = null;
private boolean existeDados = false;
private byte[] dados = null;
private ComunicacaoSerial() {
}
public static ComunicacaoSerial getReference() {
if (null == comunicacaoSerial) {
comunicacaoSerial = new ComunicacaoSerial();
}
return comunicacaoSerial;
}
public void conexao(String nomePorta, int velocidade, int dataBits,
int stopBits, int paridade) {
try {
CommPortIdentifier portIdentifier = CommPortIdentifier
.getPortIdentifier(nomePorta);
if (portIdentifier.isCurrentlyOwned()) {
System.out.println("Erro: Porta " + nomePorta
+ " já está em uso.");
} else {
CommPort commPort = portIdentifier.open("ComunicacaoSerial",
2000);
if (commPort instanceof SerialPort) {
serialPort = (SerialPort) commPort;
serialPort.setSerialPortParams(velocidade, dataBits,
stopBits, paridade);
serialPort.setRTS(true);
serialPort.setDTR(true);
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
entrada = serialPort.getInputStream();
saida = serialPort.getOutputStream();
} else {
System.out.println("Erro: " + nomePorta
+ " não é uma porta serial");
}
}
} catch (NoSuchPortException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (PortInUseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (UnsupportedCommOperationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (TooManyListenersException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public byte[] leituraPortaSerial() {
byte[] buffer = null;
ByteArrayOutputStream dadosLidos = new ByteArrayOutputStream();
try {
while (entrada.available() > 0)
{
dadosLidos.write(entrada.read());
}
buffer = dadosLidos.toByteArray();
dadosLidos.close();
} catch (IOException e) {
e.printStackTrace();
}
return buffer;
}
public byte leituraStatusPortaSerial() {
byte buffer = 0;
try {
buffer = (byte) entrada.read();
} catch (IOException e) {
e.printStackTrace();
}
return buffer;
}
public void escritaPortaSerial(byte[] dadosEscrita) {
try {
saida.write(dadosEscrita);
} catch (IOException e) {
e.printStackTrace();
}
}
@SuppressWarnings("unchecked")
public void listaPortas() {
Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
System.out.println("PORTAS ENCONTRADAS:");
while (portEnum.hasMoreElements()) {
CommPortIdentifier portIdentifier = (CommPortIdentifier) portEnum
.nextElement();
System.out.println(portIdentifier.getName() + " - "
+ getTipoPorta(portIdentifier.getPortType()));
}
}
@SuppressWarnings("unchecked")
public List<String> getPortas() {
Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();
List<String> portas = new ArrayList<String>();
while (portEnum.hasMoreElements()) {
CommPortIdentifier portIdentifier = (CommPortIdentifier) portEnum.nextElement();
portas.add(portIdentifier.getName());
}
return portas;
}
private String getTipoPorta(int tipoPorta) {
switch (tipoPorta) {
case CommPortIdentifier.PORT_I2C:
return "I2C";
case CommPortIdentifier.PORT_PARALLEL:
return "Parallel";
case CommPortIdentifier.PORT_RAW:
return "Raw";
case CommPortIdentifier.PORT_RS485:
return "RS485";
case CommPortIdentifier.PORT_SERIAL:
return "Serial";
default:
return "unknown type";
}
}
public void fechaConexao() {
try {
entrada.close();
saida.close();
serialPort.removeEventListener();
serialPort.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void serialEvent(SerialPortEvent event) {
switch (event.getEventType()) {
case SerialPortEvent.BI:
case SerialPortEvent.OE:
case SerialPortEvent.FE:
case SerialPortEvent.PE:
case SerialPortEvent.CD:
case SerialPortEvent.CTS:
case SerialPortEvent.DSR:
case SerialPortEvent.RI:
break;
case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
break;
case SerialPortEvent.DATA_AVAILABLE:
dados = leituraPortaSerial();
existeDados = true;
break;
}
}
public byte[] getDados() {
//existeDados = false;
return dados;
}
public boolean existeDadosDisponiveis() {
return existeDados;
}
}[/code]
Exemplo de como usufruir dessa classe:
String printerCodes = char(13); //char de 13 é o enter, ou em binario, 00001101
ComunicacaoSerial comunica = ComunicacaoSerial.getReference ();
comunica.conexao ("COM1",1234,2, 1,0); //esses dados eu inventei, vai depender da configuracao da sua porta no Sistema Operacional.
comunica.escritaPortaSerial (printerCodes.getBytes ());
Obs.: Eu nao testei o codigo acima, mas se tiver algo errado é detalhe, além do mais, voce pode olhar como funciona a classe utilitaria que passei.
Não esqueça de baixar a api para conexao com portas seriais, RXTXCOMM
Boa sorte 
Muito obrigado yorgan e gqferreira pelo interesse em ajudar… :idea:
Vou pesquisar mais sobre o assunto…
abraço
ribeiro220,
Se você realmente quer mexer a nível tão baixo lidando diretamente com o hardware e fazer coisas pra automação, sugiro que vc faça isto em C++ que vai lhe permitir ficar mais próximo do hardware. E aí, se quiser desenvolver aplicação Java que faça acesso a estas coisas, faça a parte de acesso em código nativo/C++ e apenas use isto no Java.
Fazendo desta forma, vc vai ter muito menos limitação e acho que vai conseguir fazer tudo o que quiser.
Entretanto… vai ter um tremendo trabalhão… rs
Taí uma coisa que eu até gostaria de fazer mas não me aventuro por falta de tempo.
Sabe como é né? A vida são escolhas… rs
Já fiz algumas coisas em C,sou iniciante em Java só não entendo esse negocio de código nativo e como fazer essa ligação de uma linguagem com outra…tipo acessar as portas em uma linguagem e integrar a mesma com um painel(desktop) feito em java
Obrigado pelas dicas
[quote=ribeiro220]
Já fiz algumas coisas em C,sou iniciante em Java só não entendo esse negocio de código nativo e como fazer essa ligação de uma linguagem com outra…tipo acessar as portas em uma linguagem e integrar a mesma com um painel(desktop) feito em java
Obrigado pelas dicas[/quote]
Um bom exemplo disso é que você irá escrever possívelmente suas dlls para comunicação com o hardware em C ou C++ e irá utilizar essas dlls no seu programa em java. Você pode fazer uso de dlls escritas em C e C++ no java por JNI ou JNA
JNI : http://java.sun.com/docs/books/jni/
JNA : https://jna.dev.java.net/
[quote=ribeiro220]
Já fiz algumas coisas em C,sou iniciante em Java só não entendo esse negocio de código nativo e como fazer essa ligação de uma linguagem com outra…tipo acessar as portas em uma linguagem e integrar a mesma com um painel(desktop) feito em java
Obrigado pelas dicas[/quote]
Já ouviu falar da palavra chave “Native” ?
http://homepages.dcc.ufmg.br/~bigonha/Cursos/Ap/Native/JavaNativeMethod.html
Caros companheiros,não sei como agradece-los,
informações como essas se fosse cobrar,seria uma fortuna!!!
É por isso que este forum só cresce,só tem profissionais 
Vou dar uma boa estudada e quando tiver avanço,comunicarei à todos…
DEUS ABENÇOE
Tenham um bom domingo