Hello SWT

Java/SWT/JFACE 2009.04.28 18:54
● 실행 화면 --------------------------------------------------------------------------------
● 샘플 소스 --------------------------------------------------------------------------------
package jezzflash.swt_jface;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

public class swt_01 
{
    public static void main(String[] args)
    {
        
        Display display = new Display();        // (1) GUI 작업을 위한 Display 객체를 생성한다.
        Shell   shell   = new Shell(display);   // (2) 윈도우를 나타내기 위한 Shell 객체를 생성한다.
        
        shell.setText( "My Eclipse SWT window" );//(3) 윈도우와 타이틀을 설정한다.
        shell.open();// (4) 윈도우를 연다.
        
        while ( !shell.isDisposed() ) // (5) 윈도우가 종료(닫힐)될 때까지 기다린다.
        {
            if ( !display.readAndDispatch() ) // (6) 윈도우에서 발생한 이벤트를 처리한다.
            {
                display.sleep(); // (7) 다른 프로그램이 CPU를 사용할 수 있도록 sleep한다.
            }
        }// end of while
        
        display.dispose(); // (8) Display 객체를 종료한다.
    }// end of main
}// end of class swt_01

'Java > SWT/JFACE' 카테고리의 다른 글

윈도우 스타일 설정과 관련된 SWT 상수  (0) 2009.05.01
이클립스 SWT의 주요 클래스  (0) 2009.05.01
Hello SWT  (0) 2009.04.28
SWT, JFace의 정의  (1) 2009.04.26
리치 클라이언트의 귀환  (0) 2009.04.26
Eclipse 에서 SWT/JFace 설정 및 테스트  (0) 2009.04.18
Posted by 써치마왕

● SWT(Standard Widget Toolkit) : SWT는 운영체제의 네이티브 윈도우 환경과 긴밀하게 통합된 컴포넌트와 플랫폼 독립적인 API를 제공한다. SWT는 자바 개발자들에게 네이티브 데스크톱을 애클리케이션과 같은 품질의 솔루션을 개발할 수 있도록 한다.

● JFace : JFace는 SWT를 이용하여 사용자 인터페이스를 개발할 때 해야 하는 많은 공통 작업들을 간단하게 해 주는 컴포넌트와 헬퍼 유틸리티 세트를 제공한다. 데이터 뷰, 위저드, 다이얼 로그 컴포넌트,  텍스트 관리, 이미지 및 폰트 컴포넌트 등을 제공하기 위해 SWT를 확장하는 많은 유틸리티 클래스들을 포함하고 있다.

● 플랫폼 런타임 : 플러그인과 JIT 레이지 로딩(Just-In-Time lazy loading) 및 초기화 간에 확장 포인트(extension-point) 모델 기반의 느슨한 결합을 정의하고 있다.

● OSGi(Open Services Gateway Initiative) : 이클립스에서 플러그인의 발견 및 애플리케이션의 재시작 없이 플러그인을 로딩 및 언로딩하는 것을 포함하여 플러그인 라이프사이클 관리등을 위한 프레임워크이다.

 - 리치 클라이언트 개발을 위한 이클립스 SWT 에서 -

'Java > SWT/JFACE' 카테고리의 다른 글

윈도우 스타일 설정과 관련된 SWT 상수  (0) 2009.05.01
이클립스 SWT의 주요 클래스  (0) 2009.05.01
Hello SWT  (0) 2009.04.28
SWT, JFace의 정의  (1) 2009.04.26
리치 클라이언트의 귀환  (0) 2009.04.26
Eclipse 에서 SWT/JFace 설정 및 테스트  (0) 2009.04.18
Posted by 써치마왕
되돌아보면 1990년대 중반부터 불어닥친 인터넷과 웹 브라우저의 보급으로 인해 현대인의 생활 패턴은 완전히 바뀌었다. 이제는 모든 생활이 인터넷에서 가능하다고 해도 과언이 아니다. 그러나 최초의 웹 브라우저인 넷스케이브와 마이크로소프트 인터넷 익스플로러의 웹 브라우저 전쟁에서 인터넷 익스플러러가 승리한 이후, 많은 웹 기반 개발자들과 사용자들은 더 이상  새로운 웹 기술의 발전을 경험하지 못했고, 점점 더 웹의 한계를 느끼게 되었다. 그나마 리눅스와 파이어폭스의 존재는 마이크로소프트가 장악하다시피 한 웹의 발전을 유지시키고 있다.

기술적으로 살펴보면 웹 브라우저를 필두로 하여 웹 페이지, 웹 서버, CGI, 웹 애플리케이션으로 이어지는 신(thin) 클라이언트가 클라이언트 PC의 기본 플랫폼이 되었고, 많은 유지 보수(특히 버그 수정과 버전 갱신) 이슈와 무거운 동작성이라은 약점을 안고 있는 리치(rich) 클라이언트는 점차 사라져 갔다. 이렇게 21세기로 넘어오면서 많은 시스템들이 웹으로 이동하였고, 웹은 초보자가 익히기에 쉽고 빠르며 이식도 아주 편했다.

하지만 사용자들이 모든 일을 웹 브라우저를 통해 하려다 보니, 빈약한 사용자 체험(user experience), 웹 엔트로피의 증가, 다양한 플랫폼 및 다중 웹 브라우저에 대한 자원 부족등의 문제들이 하나씩 생겨났다. HTML의 단순한 사용자 인터페이스가 주는 제약을 뛰어 넘기 위해 DHTML, 자바스크립트, 액티브X 컨트롤, 플래시가 범람하게 된 것이다. 이는 결국 브라우저로 대표되는 신 클라이언트가 다시 무거워지는 계기로 작용했다. 그리고 이러한 혼란의 시대에 어디론가 사라졌던 리치 클라이언트가 귀환하게 되었다.

플래시는 리치 클라이언트의 부활을 알리는 첫 신호탄이었다. 기존의 웹에서 볼 수 없었던 풍부한 사용자 체험을 제공했으며, 프로그래밍이 가능한 플렉스로 발전하였다. 그러나 플렉스가 리치 인터넷 애플리케이션(Rich Internet Application; RIA)이라고 스스로 말하고 있듯이, 웹 브라우저 내에서 실행되기 때문에 웹이라는 태생적인 한계를 벗어나지 못하고 있다. 웹 2.0을 구현할 기술의 하나로 주목받고 있는 AJAX(Asynchronous JavaScript and XML) 역시 기존의 웹과 HTML의 웹 엔트로피 과다 생산 문제점을 보완하기 위해서 생겨난 하나의 웹 기술에 불과하다.

이러한 상황에서 이클립스 리치 클라이언트 플랫폼(Rich Client Platform; RCP)은 신선한 충격으로 다가왔다. 다중 크로스 플랫폼 환경에서 매우 잘 상호 작용하는 비즈니스 애플리케이션을 생성하기 위해 필요한 모든 요구 사항들을 만족시켜 주기에 충분하다고 생각한다. 물론 웹 애플리케이션은 여전히 큰 장점을 가지고 있고 AJAX와 웹 2.0 같은 기술과 함께 보다 진일보하고 있다. 동시에 리치 클라이언트 애플리케이션은 일부 애플리케이션에 더 잘 맞는다. 그 예로, 은행 창구(Bank Teller) 애플리케이션이나 콜 센터(Call Center) 애플리케이션등을 들 수 있다.

이와 같은 경우, 애플리케이션은 일반적으로 다음과 같은 특징이 있다.
● 대부분 수백, 수천 명의 사용자들 타깃으로 한 내부 인트라넷 애플리케이션이다.
● 폰트, 컬러, 위젯등 UI에 대한 엄격한 룩앤필(Look and Feel)요구 사항이 있다.
● 파워 유저가 사용하는 것이기 때문에 단축키를 사용한 빠른 반응을 필요로 한다.
● 이러한 애플리케이션들은 매우 큰 데이터 세트를 갖고 있고 스크린에 많은 정보를
    디스플레이 한다. 클라이언토 측에 큰 세션 데이터를 관리하여 퍼포먼스를 높인다.
● 데스크톱과 다른 데스크톱 애플리케이션을 통합한다.
● 일반적으로 워크플로 유형 또는 협업 유형의 애플리케이션이고, 오프라인에서 작업
    할 수 있는 기능과 태스크 변환 기능이 매우 중요하다.

세상에 존재하는, 인간이 만든 모든 것 중 완벽한 것이 없듯이 컴퓨터 프로그래밍도 마찬가지이다. 따라서 리치 클라이언트와 신 클라이언트는 서로 역할을 명확히 구분하여 상호 보완해야 할 것이다.


-리치 클라이언트 개발을 위한 이클립스 SWT 로 부터 -

'Java > SWT/JFACE' 카테고리의 다른 글

윈도우 스타일 설정과 관련된 SWT 상수  (0) 2009.05.01
이클립스 SWT의 주요 클래스  (0) 2009.05.01
Hello SWT  (0) 2009.04.28
SWT, JFace의 정의  (1) 2009.04.26
리치 클라이언트의 귀환  (0) 2009.04.26
Eclipse 에서 SWT/JFace 설정 및 테스트  (0) 2009.04.18
Posted by 써치마왕
2009년 5월 2일은 황금 연휴라고 쉬자고 해서 쉬겠습니다.

금일 미션 :
                 영민, 경원 - SWT FILE OPEN CLASS 만들기
                 덕형         - read(), write() 함수를 이용한 !EZLOAD 인식

다다음주 미션 :
                 영민, 경원 -
                 덕형         - EZAT7에 module 라이트하기
                                   이클립스에서 svn 사용법 문서화

'FSP21 > SWT/JFACE를 이용한 EZFLASH' 카테고리의 다른 글

2009_05_09 JEZZFLASH 작업 파일  (0) 2009.05.09
2009년 4월 25일 진행사항  (0) 2009.04.25
2009년 4월 18일 진행사항  (0) 2009.04.25
2009년 4월 11일 진행사항  (0) 2009.04.14
고쳐야 할점  (0) 2009.04.13
Posted by 써치마왕
회의 내용 정리
 - 디렉토리 :  jezzflash\work\jezzproject  => 작업 디렉토리
                    jezzflash\work\package     => 개발 환경 구축에 필요한 파일들 모음
 
 - Version :   eclipse 는        3.4.2 버젼
                   java jdk는         1.6.11 버젼
                   swt/jface는       eclipse 3.4.2 버젼에 포함된 버젼

지난 주 숙제
 - SWT/JFACE를 이용해서 Hellow World!를 출력
 - 리턴 정의
 => 성 공

이번 주 미션
- 시리얼 송수신 프로그램 작성
- 리턴 정의
=> 성 공

이번 주 숙제
- 시리얼 read, write 함수를 작성하여 데이터를 송수신
- ex) write( 엔터 ) ==>  buf = read() : buf = !EZLOAD>

해결해야 할 과제
- 시리얼 포트를 안전하게 닫는 기능

'FSP21 > SWT/JFACE를 이용한 EZFLASH' 카테고리의 다른 글

2009_05_09 JEZZFLASH 작업 파일  (0) 2009.05.09
2009년 4월 25일 진행사항  (0) 2009.04.25
2009년 4월 18일 진행사항  (0) 2009.04.25
2009년 4월 11일 진행사항  (0) 2009.04.14
고쳐야 할점  (0) 2009.04.13
Posted by 써치마왕
package jezz.pack;

import java.io.*;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;

public class StartUsart extends Thread implements SerialPortEventListener 
{
    UsartSWT    swt     = null;
    Usart       usart   = null;
    
    public static void main(String[] args)
    {
        new StartUsart();
    }
    
    public StartUsart()
    {
        this.swt    = new UsartSWT(this);
        this.usart  = new Usart( new String("com5").toUpperCase(),  115200 );
        this.usart.addEventListener(this);
    }

    public void debug(String msg)
    {
        System.out.println(msg);
    }
    
    // Serial read Listener
    public void serialEvent(SerialPortEvent evnet)
    {
        this.debug( this.usart.read() );
    }
    
    public void write(String msg)
    {
        this.usart.write( msg );
    }
}

'Java > rxtxSerial' 카테고리의 다른 글

3 - rxtxSerial + SWT (StartUsart.java)  (0) 2009.04.25
2 - rxtxSerial + SWT (Usart.java)  (0) 2009.04.25
1 - rxtxSerial + SWT (UsartSWT.java)  (0) 2009.04.25
시리얼 장치를 스캔 CMD를 비교  (0) 2009.04.25
Posted by 써치마왕
 

package jezz.pack;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.util.TooManyListenersException;

import gnu.io.CommPortIdentifier;
import gnu.io.NoSuchPortException;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEventListener;
import gnu.io.UnsupportedCommOperationException;

public class Usart 
{
    private SerialPort          port    = null;
    private CommPortIdentifier  port_id = null;
    private BufferedInputStream in      = null;
    private BufferedOutputStream out    = null;
    
    public Usart(String port, int speed )
    {
        connect( port, speed );
    }
    
    public void connect(String port_name, int speed )
    {
        // 포트 찾기
        try
        {
            this.port_id = CommPortIdentifier.getPortIdentifier( port_name );
        }
        catch ( NoSuchPortException e)
        {
            this.debug( port_name + " 포트를 찾을 수 없습니다." );
            System.exit(0);
        }
        
        // 포트 열기
        try
        {
            this.port = (SerialPort)this.port_id.open( "usart", 2000 );
        }
        catch ( PortInUseException e )
        {
            this.debug( this.port + " 이미 사용중인 포트입니다.");
            System.exit(0);
        }
        
        // I/O 열기
        try
        {
            this.in     = new BufferedInputStream( this.port.getInputStream() );
            this.out    = new BufferedOutputStream( this.port.getOutputStream() );
        }
        catch ( IOException e )
        {
            this.debug( " I/O를 열수 없습니다. ");
            System.exit(0);
        }
        
        // 포트 설정
        try
        {
            this.port.setSerialPortParams(  speed,
                                            SerialPort.DATABITS_8,
                                            SerialPort.STOPBITS_1,
                                            SerialPort.PARITY_NONE );
        }
        catch ( UnsupportedCommOperationException e )
        {
            this.debug( e.toString() );
        }
        
        // 데이터가 수신되면 이벤트 리스너를 깨우기
        this.port.notifyOnDataAvailable( true );
        // 출력이 없을때도 깨우기
        this.port.notifyOnOutputEmpty( true );
    }// end of connect
    
    // 이벤트 리스너 등록
    public  void addEventListener( SerialPortEventListener e )
    {
        try
        {
            this.port.addEventListener( e );
        }
        catch ( TooManyListenersException ee )
        {
            this.debug( ee.toString() );
        }
    }// end of addEventListener
    
    public SerialPort getSerialPort()
    {
        return this.port;
    }// end of getSerialPort
    
    public BufferedInputStream getInputStream()
    {
        return this.in;
    }// end of getInputStream
    
    public BufferedOutputStream getOutputStream()
    {
        return this.out;
    }// end of getOutputStream
    
    public CommPortIdentifier getPortIdentifer()
    {
        return this.port_id;
    }// end of getPortIdentifer
    
    public void debug( String msg )
    {
        System.out.println( msg );
    }// end of debug
    
    public void write( String msg )
    {
        try
        {
            this.getOutputStream().write( msg.getBytes() );
            this.getOutputStream().flush();
        }
        catch ( IOException e )
        {
            this.debug( e.toString() );
        }
    }// end of write
    
    public String read()
    {
        byte    buf[] = new byte[512];
        
        try
        {
            while ( this.getInputStream().available() > 0 )
            {
                this.getInputStream().read( buf );
            }
        }
        catch ( IOException e )
        {
            this.debug( e.toString() );
        }
        
        return new String(buf).trim();
    }// end of read
} // end of class Usart

'Java > rxtxSerial' 카테고리의 다른 글

3 - rxtxSerial + SWT (StartUsart.java)  (0) 2009.04.25
2 - rxtxSerial + SWT (Usart.java)  (0) 2009.04.25
1 - rxtxSerial + SWT (UsartSWT.java)  (0) 2009.04.25
시리얼 장치를 스캔 CMD를 비교  (0) 2009.04.25
Posted by 써치마왕
package jezz.pack;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Text;

public class UsartSWT extends Thread implements
    org.eclipse.swt.events.SelectionListener
{
    private org.eclipse.swt.widgets.Shell sShell = null;
    
    private static final String title = "Serial Control";
    
    private boolean isClosing = false;
    
    private Composite   composite = null;
    private Composite   composite1 = null;
    private Composite   composite2 = null;
    
    private Button exit = null;
    private Button led1 = null;
    private Button led2 = null;
    private Button led3 = null;
    private Button led4 = null;
    private Button led5 = null;
    private Button led6 = null;
    private Button led7 = null;
    private Button led8 = null;
    
    private StartUsart usart = null;
    
    private Text cmd    = null;
    private Text debug  = null;
    
    private void cerateComposite()
    {
        RowLayout   rowLayout   = new RowLayout();
        
        rowLayout.type          = org.eclipse.swt.SWT.VERTICAL;
        rowLayout.justify       = false;
        rowLayout.wrap          = true;
        rowLayout.pack          = true;
        rowLayout.marginWidth   = 0;
        rowLayout.fill          = true;
        
        composite = new Composite( composite1, SWT.NONE );
        cerateComposite2();
        composite.setLayout( rowLayout );
        exit = new Button( composite, SWT.NONE );
        exit.setText( "Exit" );
        exit.addSelectionListener( this );
        
        cmd = new Text( composite, SWT.BORDER );
        cmd.addKeyListener( new org.eclipse.swt.events.KeyAdapter()
        {
            public void KeyReleased(org.eclipse.swt.events.KeyEvent e)
            {
                if ( e.keyCode == 0x0D )
                {
                    usart.write( cmd.getText() );
                    cmd.setText("");
                }
            }
        });
    }// end of cerateComposite
    
    private void cerateComposite1()
    {
        composite1 = new Composite( sShell, SWT.NONE );
        composite1.setLayout( new FillLayout() );
        cerateComposite();
    }// end of cerateComposite1
    
    private void cerateComposite2()
    {
        GridLayout  gridLayout = new GridLayout();
        gridLayout.numColumns = 8;
        gridLayout.makeColumnsEqualWidth = false;
        
        composite2 = new Composite( composite, SWT.NONE );
        composite2.setLayout( gridLayout );
        
        led8 = new Button(composite2, SWT.NONE );
        led8.setText( "8" );
        led7 = new Button(composite2, SWT.NONE );
        led7.setText( "7" );
        led6 = new Button(composite2, SWT.NONE );
        led6.setText( "6" );
        led5 = new Button(composite2, SWT.NONE );
        led5.setText( "5" );
        led4 = new Button(composite2, SWT.NONE );
        led4.setText( "4" );
        led3 = new Button(composite2, SWT.NONE );
        led3.setText( "3" );
        led2 = new Button(composite2, SWT.NONE );
        led2.setText( "2" );
        led1 = new Button(composite2, SWT.NONE );
        led1.setText( "1" );
        
        led8.addSelectionListener( this );
        led7.addSelectionListener( this );
        led6.addSelectionListener( this );
        led5.addSelectionListener( this );
        led4.addSelectionListener( this );
        led3.addSelectionListener( this );
        led2.addSelectionListener( this );
        led1.addSelectionListener( this );
    }// end of cerateComposite2
    
    public UsartSWT( StartUsart parent )
    {
        this.usart = parent;
        start();
    }
    
    public void run()
    {
        org.eclipse.swt.widgets.Display display = org.eclipse.swt.widgets.Display.getDefault();
        
        createSShell();
        sShell.open();
        
        while ( !sShell.isDisposed() )
        {
            if ( !display.readAndDispatch() )
            {
                display.sleep();
            }
        }
    }// end of run
    
    private void createSShell()
    {
        sShell  = new org.eclipse.swt.widgets.Shell();
        sShell.setLayout( new FillLayout() );
        sShell.setText( title );
        
        cerateComposite1();
        sShell.setSize( new Point(605, 128) );
        debug = new Text( sShell, SWT.MULTI | SWT.WRAP | SWT.V_SCROLL );
        sShell.addShellListener( new org.eclipse.swt.events.ShellAdapter()
        {
            public void shellClosed(org.eclipse.swt.events.ShellEvent e)
            {
                if ( !isClosing )
                {
                    e.doit = doExit();
                }
            }
        });
    }// end of createSShell
    
    private boolean doExit()
    {
        isClosing = true;
        sShell.close();
        sShell.dispose();
        System.exit(0);
        return true;
    }// end of doExit
    
    public void widgetDefaultSelected( SelectionEvent e )
    {
    }// end of widgetDefaultSelected
    
    public void widgetSelected( SelectionEvent e )
    {
        if ( e.getSource() == this.exit )
        {
            this.doExit();
        }
        else if ( e.getSource() == this.led8 )
        {
            usart.write("8");
        }
        else if ( e.getSource() == this.led7 )
        {
            usart.write("7");
        }
        else if ( e.getSource() == this.led6 )
        {
            usart.write("6");
        }
        else if ( e.getSource() == this.led5 )
        {
            usart.write("5");
        }
        else if ( e.getSource() == this.led4 )
        {
            usart.write("4");
        }
        else if ( e.getSource() == this.led3 )
        {
            usart.write("3");
        }
        else if ( e.getSource() == this.led2 )
        {
            usart.write("2");
        }
        else if ( e.getSource() == this.led1 )
        {
            usart.write("1");
        }
    }// end of widgetSelected
}

'Java > rxtxSerial' 카테고리의 다른 글

3 - rxtxSerial + SWT (StartUsart.java)  (0) 2009.04.25
2 - rxtxSerial + SWT (Usart.java)  (0) 2009.04.25
1 - rxtxSerial + SWT (UsartSWT.java)  (0) 2009.04.25
시리얼 장치를 스캔 CMD를 비교  (0) 2009.04.25
Posted by 써치마왕
 

package jezzflash.rxtxserial;

import java.io.*;
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.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.TooManyListenersException;

public class port_scan
{
         // 포트 찾기
         // 포트 열기
         // 포트 설정
         // EZ-AT7 찾기(!EZLOAD>, !EZMODULE>)

    static  int                 global_port_number              = 0;
    static SerialPort           global_serial_port_handle       = null;
    static CommPortIdentifier   global_serial_port_identifier   = null;
    static InputStream          global_in_stream                = null;
    static OutputStream         global_out_stream               = null;
    // 시리얼 장치 포트 이름을 저장
    static String[]             port_store                      = new String[32];
    
    Thread  read_thread     =   null;
    Thread  write_thread    =   null;

    //---------------------------------------------------------------
    //---------------------------------------------------------------
    //---------------------------------------------------------------
    public int get_port_number()
    {
        return (this.global_port_number);
    }
    public void set_port_number( int port_number )
    {
        this.global_port_number = port_number;
    }

    public void set_serial_port_handle( SerialPort port_handle )
    {
        global_serial_port_handle = port_handle;
    }
    public SerialPort get_serial_port_handle()
    {
        return global_serial_port_handle;
    }

    public CommPortIdentifier get_serial_port_identifier()
    {
        return global_serial_port_identifier;
    }
    public void set_serial_port_identifier(CommPortIdentifier port_identifier)
    {
        global_serial_port_identifier = port_identifier;
    }
    
    public InputStream get_input_stream()
    {
        return global_in_stream;
    }
    public void set_input_stream(InputStream input_stream)
    {
        global_in_stream = input_stream;
    }

    public OutputStream get_output_stream()
    {
        return global_out_stream;
    }
    public void set_output_stream(OutputStream output_stream)
    {
        global_out_stream = output_stream;
    }
    //---------------------------------------------------------------
    //---------------------------------------------------------------
    //---------------------------------------------------------------
    
    //---------------------------------------------------------------
    // 함 수 설 명 : msec 지연을 한다.
    // 매 개 변 수 : msec 시간 값
    // 리 턴 정 의  : 없음
    //---------------------------------------------------------------
    public static void mdelay( long delay_time )
    {
        long    save_time   =   System.currentTimeMillis();
        long    curr_time   =   0; 
        
        while ( (curr_time - save_time) < delay_time ) 
        {
            curr_time = System.currentTimeMillis();
        }
    }// end of mdelay

         
    //---------------------------------------------------------------
    // 함 수 설 명 : 시리얼 장치를 찾는다.
    // 매 개 변 수 : 없음
    // 전역 배 열  : port_store : 시리얼 장치 이름을 저장
    // 리 턴 정 의  : -1                             시리얼 장치 찾기 실패
    //             그외                       시리얼 장치 개수
    //---------------------------------------------------------------
    public int get_serial_port()
    {
        CommPortIdentifier  port_id     = null;
        Enumeration         port_list   = null;
        int                 port_cnt    = 0;

        // 포트의 식별자 정보를 받아온다. 
        port_list = CommPortIdentifier.getPortIdentifiers();
        while ( port_list.hasMoreElements() ) // 포트의 개수가  있으면 true, 없으면 false
        {
            // 다음 포트의 식별자 정보를 받아온다.
            port_id = (CommPortIdentifier)port_list.nextElement();
            
            // 포트가 시리얼 포트 타입이라면

            if ( port_id.getPortType() == CommPortIdentifier.PORT_SERIAL )
            {
                  //System.out.println( port_id.getName() ); // 포트의이름을 출력한다.
                  port_store[port_cnt++] = port_id.getName();// 포트의 이름을 저장한다.
            }
        }
        
        // 포트를 찾았는지 검사한다.
        if ( port_cnt <= 0 )    return (-1);
        else                    return port_cnt;
    }// end of get_serial_port

    //---------------------------------------------------------------
    // 시리얼 포트 찾기
    public int get_comport_device()
    {
        CommPortIdentifier  find_port = null;
        
        //int port_tot  = 0;
        int     port_num = 0;
        
        //port_tot = this.get_serial_port(); // 전체 시리얼 포트의 개수를 구한다.
        port_num = get_port_number();        // 현재 시리얼 포트  번호를 구한다.

        try 
        {
            find_port = CommPortIdentifier.getPortIdentifier( port_store[port_num] );
        }
        catch ( NoSuchPortException e ) 
        {
            System.out.println( "@ " + port_store[port_num] + ": COM" +port_num +  " : 포트를 찾을 수 없음 @" );
            return (-1);
        }
        
        set_serial_port_identifier( find_port );

        return (0);
    }// end of get_comport_device

    //---------------------------------------------------------------
    // 시리얼 포트 열기
    public int comport_open( CommPortIdentifier  find_port )
    {
        SerialPort  open_port   = null;
        int         port_num    = 0;

        port_num  = get_port_number();     // 현재 시리얼 포트  번호를 구한다.
        open_port = get_serial_port_handle();

        try
        {
            open_port = (SerialPort)find_port.open( this.getClass().getName(), 2000 );
        }
        catch (PortInUseException e)
        {
            System.out.println( "@ " + port_store[port_num] + ": COM" +port_num +  " : 이미 사용중인 포트 @" );
            return (-1);
         }
        
        set_serial_port_handle( open_port ); // 시리얼 포트 핸들을 저장한다.
        return (0);
    }// end of comport_open
    
    //---------------------------------------------------------------
    // 시리얼 포트 설정
    public int comport_setting( int baud )
    {
        int         port_num    = 0;
        SerialPort  open_port   = null;

        port_num = get_port_number();           // 현재 시리얼 포트  번호를 구한다.
        open_port = get_serial_port_handle();   // 시리얼 포트 핸들을 얻는다.
        
        try
        {
            open_port.setSerialPortParams( baud,
                           SerialPort.DATABITS_8,
                           SerialPort.STOPBITS_1,
                           SerialPort.PARITY_NONE );

            // 흐름제어를 사용하지 않는다.
            // open_port.setFlowControlMode( SerialPort.FLOWCONTROL_NONE );
        }
        catch ( UnsupportedCommOperationException e)
        {
            System.out.println( "@ " + port_store[port_num] + ": COM" +port_num +  " : 포트를 설정 할 수 없음 @" );
            return (-1);
        }
    
        return (0);
    }// end of comport_setting

    //---------------------------------------------------------------
    // 시리얼 포트를 닫는다.
    public void comport_close(SerialPort port_handle)
    {
        port_handle.close();
    }// end of comport_close

    //---------------------------------------------------------------
    // 시리얼 통신을 사용할 수있도록 설정한다.
    public int set_using_comport( int port_num )
    {
        CommPortIdentifier  find_port       = null;
        int                 ret             = 0;
        int                 port_tot        = 0;
        
        port_tot = this.get_serial_port();  // 시리얼 포트의 개수를 구한다.
        if (port_tot <= port_num )
        {
            System.out.println("시리얼 포트 번호가 잘못되었습니다.");
            return (-1);
        }
        
        set_port_number(port_num); // 현재의 시리얼 포트 번호를 저장
        ret = get_comport_device(); // 시리얼 포트 찾기
        if ( ret < 0 )
        {
            System.out.println( "@ " + port_store[port_num] + ": COM" +port_num +  " : 포트를 찾을 수 없음 @" );
            return (-1);
        }         

        // 시리얼 포트 식별자 정보를 얻는다.
        find_port = get_serial_port_identifier();
        
        // 포트 열기
        ret = comport_open( find_port );
        if ( ret < 0 )
        {
            System.out.println( "@ " + port_store[port_num] + ": COM" +port_num +  " : 포트를 열수 없음 @" );
            return (-1);
        }

        // 포트 설정
        ret = comport_setting( 115200 );
        if ( ret < 0 )
        {
            System.out.println( "@ " + port_store[port_num] + ": COM" +port_num +  " : 포트를 설정 할 수 없음 @" );
            return (-1);
        }
        
        return (0);
    }// end of get_using_comport
    
    // 데이터를 수신하면 이벤트 리스너를 깨운다.
    // open_port.notifyOnDataAvailable(true);
    // 출력이 없을때도 이벤트 리스너를 깨운다.
    // open_port.notifyOnOutputEmpty(true);
    
    //---------------------------------------------------------------
    // 시리얼 통신을 실행한다.
    public void set_serial_run()
    {
        SerialPort  open_port   = null;
        
        open_port = get_serial_port_handle();       // 시리얼 포트 핸들을 얻는다.
        
        // 쓰레드를 생성하고, 시작 시킨다.
        InputStream     in_stream   = null;
        OutputStream    out_stream  = null;
        
        try 
        {
            in_stream = open_port.getInputStream();
            out_stream        = open_port.getOutputStream();
        }
        catch (IOException e) 
        {
        }

        // stream io를 저장한다.
        set_input_stream( in_stream );
        set_output_stream( out_stream );
        
        //read_thread = new Thread(new serial_reader(in_stream) );
        //write_thread =  new Thread(new serial_writer(out_stream) );
        
        //read_thread.start();
        //write_thread.start();
        //return (0);
    }// end of set_serial_run
    
    //---------------------------------------------------------------
    // 시리얼 포트에 String 데이터를 쓴다.
    public void write(String msg)
    {
        OutputStream    out_stream = null;
        
        out_stream = get_output_stream();
                
        try
        {
            out_stream.write( msg.getBytes() );
            out_stream.flush();
        } 
        catch ( IOException e )
        {
            System.out.println( "serial_write : error" );
            //this.debug( e.toString() );
        }
    }// end of write

    //---------------------------------------------------------------
    // 시리얼 포트에 int 데이터를 쓴다.
    public void write(int msg)
    {
        OutputStream    out_stream = null;
                 
        out_stream = get_output_stream();
                 
        try
        {
            out_stream.write( msg );
            out_stream.flush();
        } 
        catch ( IOException e)
        {
            System.out.println( "serial_write : error" );
            //this.debug( e.toString() );
        }
    }// end of write

    //---------------------------------------------------------------
    // 시리얼 포트에서  String 데이터를읽는다.
    public String read()
    {
        InputStream in_stream   = null;
        byte        buf[]       = new byte[512];
        
        in_stream = this.get_input_stream();
        try
        {
            while ( in_stream.available() > 0 )
            {
                in_stream.read(buf);
            }
        }
        catch ( IOException e )
        {
            System.out.println( "serial_read : error" );
        }
        
        return new String(buf).trim();
    }// end of reads
    
    //---------------------------------------------------------------
    // 함수 설명 : 정해진 시간에 문자가 수신했는지 확인한다.
    // 리턴정의  : 0   : 성공
    //           -1   : 실패
    //---------------------------------------------------------------
    public int read_ok( long delay_time )
    {
        long    save_time   =   System.currentTimeMillis();
        long    curr_time   =   0;
        InputStream in_stream   = null;
        
        in_stream = this.get_input_stream();
        
        while ( (curr_time - save_time) < delay_time ) 
        {
            //curr_time = System.currentTimeMillis();
            try
            {
                if ( in_stream.available() > 0 )
                {
                    return (0);
                }
            }
            catch (IOException e )
            {
                System.out.println( "read_ok catch error" );
            }
            curr_time = System.currentTimeMillis();
        }
        return (-1);
    }// end of read_ok
    
    //---------------------------------------------------------------
    // 함수 설명 : EZ-AT7인지를 확인한다.
    // 매개 변수 : cnt    : 횟수를 정한다.
    // 리턴정의  : true   : 성공
    //           flase  :  실패
    //---------------------------------------------------------------
    public boolean get_match_ezat7( int cnt )
    {
        final String    EZLOAD      = "!EZLOAD";
        final String    EZMODULE    = "!EZMODULE";
        
        for (int lp = 0 ; lp < cnt ; lp++ )
        {
            this.write( 1000 ); // 엔터 명령을 보낸다.
            
            if ( this.read_ok(1000) > -1 )
            {
                String ezat7_cmd = this.read();
                System.out.println( "main : " + ezat7_cmd );
                
                if ( ezat7_cmd.compareTo(EZLOAD) > 0 )
                {
                    System.out.println( "main : " + "ezat7_cmd.compareTo(!EZLOAD) ok" );
                    return true;
                }
                else if ( ezat7_cmd.compareTo(EZMODULE) > 0 )
                {
                    System.out.println( "main : " + "ezat7_cmd.compareTo(!EZMODULE) ok" );
                    return true;
                }
            }
            else
            {
                System.out.println( "main : " + " 수신 문자를 받지 못했다." );
                continue;
            }
        }
        return false;
    }// end of get_match_ezat7
    
    //---------------------------------------------------------------
    // 시리얼 리더 쓰레드 
    public static class serial_reader implements Runnable
    {
        InputStream in_stream = null;
                  
        public serial_reader(InputStream in) 
        {
            this.in_stream = in;
        }

        public void run()
        {
            byte[] buffer = new byte[512];

            try
            {
                if ( in_stream.available() > 0 )
                {
                    in_stream.read( buffer );
                }
            }
            catch ( IOException e )
            {
                System.out.println( "serial_reader : error " );
            }
        }
    }// end of serial_reader
    
    //---------------------------------------------------------------
    // 시리얼라이터 쓰레드
    public static class serial_writer implements Runnable
    {
        OutputStream out_stream = null;
        
        public serial_writer( OutputStream out ) 
        {
            this.out_stream = out;
        }

        public void run() 
        {
            //try 
            //{
            // this.out_stream.write( 0x0D );
            // mdelay(1000);
            //} 
            //catch (IOException e) 
            //{
            //e.printStackTrace();
            //}
        }
         }// end of serial_writer
    
    //---------------------------------------------------------------
    // 메인 함수
    //---------------------------------------------------------------
    public static void main( String[] args )
    {
        String      str         = null;
        SerialPort  open_port   = null;
        int         port_tot    = 0;
        int         ret         = 0;
        port_scan   serial_port       = new port_scan();
        
        port_tot = serial_port.get_serial_port();
        System.out.println("main : 시리얼 포트 총 갯수 : " + port_tot );
                 
        for (int port_cnt = 0 ; port_cnt < port_tot ; port_cnt++ )
        {
            System.out.println("main : 시리얼  포트 : " + port_store[port_cnt] );
            
            ret = serial_port.set_using_comport( port_cnt );
            if ( ret < 0 )
            {
                // 시리얼 포트 핸들을 얻는다.
                open_port = serial_port.get_serial_port_handle();     
                serial_port.comport_close( open_port );
                System.out.println("main : " + " : " + port_store[port_cnt] + " 사용 가능 하지 않음");
                System.exit(0);
            }
            
            // 스트림 IO를 연결한다.
            serial_port.set_serial_run();
            System.out.println("main : " + port_store[port_cnt] + " Running");
            
            // EZ-AT7을 찾는다.
            boolean dig_ret = serial_port.get_match_ezat7( 3 );
            if ( dig_ret == true )
            {
                System.out.println( "찾았다!!" );
            }
            else
            {
                System.out.println( "!!못찾았다." );
            }

            // 시리얼 포트 핸들을 얻는다.
            open_port = serial_port.get_serial_port_handle();     
            serial_port.comport_close( open_port );
            //str = str.replaceAll( "\\p{Space}", "" );
            //System.out.println( "main :read() : " + str );
        }
    }// end of main
}// end of class port_scan
결과

'Java > rxtxSerial' 카테고리의 다른 글

3 - rxtxSerial + SWT (StartUsart.java)  (0) 2009.04.25
2 - rxtxSerial + SWT (Usart.java)  (0) 2009.04.25
1 - rxtxSerial + SWT (UsartSWT.java)  (0) 2009.04.25
시리얼 장치를 스캔 CMD를 비교  (0) 2009.04.25
Posted by 써치마왕
 
byte[]     buf  =  new  byte[32];
String     bufs;

System.out.println(  new  String(buf, 0, 32) );
bufs = new String(  buf, 0, 32 );

'Java' 카테고리의 다른 글

byte 데이터를 String 으로 출력  (0) 2009.04.19
mdelay 함수를 만들자  (0) 2009.04.19
eclipse 설치 및 테스트  (0) 2009.04.15
JDK 환경 변수 설정 및 설치 확인  (1) 2009.04.14
JDK 설치  (0) 2009.04.14
JRE 설치  (0) 2009.04.14
Posted by 써치마왕