×

Welcome to TagMyCode

Please login or create account to add a snippet.
0
0
 
0
Language: Text
Posted by: juan marin
Added: Aug 20, 2016 11:47 AM
Views: 2
Tags: no tags
Java serial port operations.
  1. package scanhandler;
  2.  
  3.  
  4. import java.awt.AWTException;
  5. import java.awt.Robot;
  6. import java.io.FileInputStream;
  7. import java.io.IOException;
  8. import java.io.InputStream;
  9. import java.sql.Connection;
  10. import java.util.Enumeration;
  11. import java.util.Properties;
  12. import java.util.TooManyListenersException;
  13. import javax.comm.CommPortIdentifier;
  14. import javax.comm.PortInUseException;
  15. import javax.comm.SerialPort;
  16. import javax.comm.SerialPortEvent;
  17. import javax.comm.SerialPortEventListener;
  18. import javax.comm.UnsupportedCommOperationException;
  19.  
  20. public class ScanHandler implements Runnable, SerialPortEventListener {
  21.  
  22.     private static CommPortIdentifier   myCommPortIdentifier;
  23.     private static Enumeration          portList;
  24.     private static String               TimeStamp;
  25.     private static String               driverClass;
  26.     private static String               connectionString;
  27.     private static String               comPort;    
  28.  
  29.     private Connection                  myConnection;
  30.     private InputStream                 myInputStream;
  31.     private Robot                       myRobot;
  32.     private SerialPort                  mySerialPort;
  33.     private Thread                      myThread;
  34.  
  35.  
  36.     public ScanHandler() {
  37.  
  38.         // open serial port
  39.         try {
  40.             TimeStamp = new java.util.Date().toString();
  41.             mySerialPort = (SerialPort) myCommPortIdentifier.open("ComControl", 2000);
  42.             //System.out.println(TimeStamp + ": " + myCommPortIdentifier.getName() + " opened for scanner input");
  43.         } catch (PortInUseException e) {
  44.             e.printStackTrace();
  45.         }
  46.  
  47.         // get serial input stream
  48.         try {
  49.             myInputStream = mySerialPort.getInputStream();
  50.         } catch (IOException e) {
  51.             e.printStackTrace();
  52.         }
  53.  
  54.         // add an event listener on the port
  55.         try {
  56.             mySerialPort.addEventListener(this);
  57.         } catch (TooManyListenersException e) {
  58.             e.printStackTrace();
  59.         }
  60.         mySerialPort.notifyOnDataAvailable(true);
  61.  
  62.         // set up the serial port properties
  63.         try {
  64.             mySerialPort.setSerialPortParams(9600,
  65.                 SerialPort.DATABITS_8,
  66.                 SerialPort.STOPBITS_1,
  67.                 SerialPort.PARITY_NONE);
  68.             mySerialPort.setDTR(false);
  69.             mySerialPort.setRTS(false);
  70.  
  71.         } catch (UnsupportedCommOperationException e) {
  72.             e.printStackTrace();
  73.         }
  74.  
  75.         // make a robot to pass keyboard data
  76.         try {
  77.             myRobot = new Robot();
  78.         } catch (AWTException e) {
  79.             e.printStackTrace();
  80.         }
  81.  
  82.         // create the thread
  83.         myThread = new Thread(this);
  84.         myThread.start();
  85.     }
  86.  
  87.     public void run() {
  88.         try {
  89.             Thread.sleep(100);
  90.         } catch (InterruptedException e) {}
  91.     }
  92.  
  93.     // on scan
  94.     public void serialEvent(SerialPortEvent event) {
  95.  
  96.         if (event.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
  97.  
  98.             StringBuilder myStringBuilder = new StringBuilder();
  99.             int c;
  100.             try {
  101.  
  102.                 // append the scanned data onto a string builder
  103.                 while ((c = myInputStream.read()) != 10){
  104.                    if (c != 13)  myStringBuilder.append((char) c);
  105.                 }              
  106.  
  107.                 // send to keyboard buffer if it the barcode doesn't start with '5'
  108.                 if (myStringBuilder.charAt(0) != '5') {
  109.  
  110.                     for (int i = 0; i < myStringBuilder.length(); i++) {
  111.                         myRobot.keyPress((int) myStringBuilder.charAt(i));
  112.                         myRobot.keyRelease((int) myStringBuilder.charAt(i));
  113.                     }
  114.  
  115.                 // here's the scanned barcode as a variable!
  116.                 } else {
  117.                     TimeStamp = new java.util.Date().toString();
  118.                     System.out.println(TimeStamp + ": scanned input received:" + myStringBuilder.toString());                    
  119.                 }
  120.  
  121.                 // close the input stream
  122.                 myInputStream.close();
  123.  
  124.             } catch (IOException e) {
  125.                 e.printStackTrace();
  126.             }
  127.         }
  128.     }
  129.  
  130.     public static void main(String[] args) {
  131.  
  132.         // read ScanHandler properties
  133.         Properties myProperties = new Properties();
  134.         try {
  135.             myProperties.load(new FileInputStream("config.properties"));
  136.             comPort             = myProperties.getProperty("ScanHandler.comPort");
  137.         } catch (IOException e) {
  138.             e.printStackTrace();
  139.         }              
  140.  
  141.         try {
  142.  
  143.             // get our pre-defined COM port
  144.             myCommPortIdentifier = CommPortIdentifier.getPortIdentifier(comPort);
  145.             ScanHandler reader = new ScanHandler();
  146.  
  147.         } catch (Exception e) {
  148.             TimeStamp = new java.util.Date().toString();
  149.             System.out.println(TimeStamp + ": " + comPort + " " + myCommPortIdentifier);
  150.             System.out.println(TimeStamp + ": msg1 - " + e);
  151.         }
  152.     };    
  153. }