RFID의 값에 따라 LED의 On/Off 제어하기

구현할 내용을 좀 더 자세히 기술하면

아두이노로부터 값(RFID)을 자바로 받아서 자바에서 서버로 전송한 후에

다시 아두이노로 데이터를 전송하는 것이다.

아두이노로부터 값(RFID)을 자바로 보내는 것은 시리얼  통신을 이용하고

웹소켓을 통해 자바에서 서버로 전송한 후에 다시 아두이노로 데이터를 전송하는 것이다.

웹소켓을 이용하면 서버에 접속한 모든 이들에게 데이터를 뿌려주는 것이 가능하다.

 

우선, 아두이노와 led, RFID를 연결한다.

led는 아두이노의 D4번핀에 연결한다. 그리고 아래의 프로그램을 업로드 한다.

아래의 내용을 참고하도록 하자. 아두이노 소스 및 아래의 자바 내용이 아래의 글과 이어지는 부분이 많다.

designatedroom87.tistory.com/330?category=903927

아두이노와 자바의 시리얼 통신(RFID)

 

LED는 아두이노의 D4번핀에 연결한다.

아두이노 소스 파일

//  흰 카드     97   A8 B6 4E
//  파란색 카드  C7  99  FF  32

#include <MFRC522.h>
#include <SPI.h>

#define   SS_PIN  10  //  칩셋핀(데이터 핀)
#define   RST_PIN 9   //  리셋핀

MFRC522 mfrc522(SS_PIN, RST_PIN);

void setup() {
  Serial.begin(9600);
  SPI.begin();            // Init SPI bus

  mfrc522.PCD_Init();     // Init mfrc522

  pinMode(4, OUTPUT);
  digitalWrite(4, LOW);
}

void loop() {
 SendRFID();  //  RFID 카드 읽기
 ReadRFID();
}

void ReadRFID()
{
  if ( Serial.available() )
  {
    byte ledState = Serial.read();

    if ( ledState == '1' )       digitalWrite(4, HIGH);
    else if ( ledState == '0' )  digitalWrite(4, LOW);
  }
}

void SendRFID()
{
   //  카드가 읽혀지지 않은 상태(찍히지 않으면)이면 리턴
  if (!mfrc522.PICC_IsNewCardPresent())   return;
  if (!mfrc522.PICC_ReadCardSerial())     return;

  ShowOtherPrintHex( mfrc522.uid.uidByte, 4 );
  
  mfrc522.PICC_HaltA();
  mfrc522.PCD_StopCrypto1(); 
}

byte GetDecimalToHex(int decimal)
{
  const int diffHex = 'A' - 10;   
  const int diffDecimal = '0';   
  byte ret;
  
  if ( decimal > 9 )  ret = diffHex + decimal;
  else                ret = diffDecimal + decimal;

  return ret;
} 

void ShowOtherPrintHex(byte* buffer, byte bufferSize)
{
  byte l_buf[8] = { 0, };
  int l_bufLen = 0;       
  
  const int l_HEX = 16;

  for (byte i = 0; i < bufferSize; i++)
  {
    int frontNum = buffer[i] / l_HEX;
    int rearNum = buffer[i] % l_HEX;

    l_buf[l_bufLen++] = GetDecimalToHex(frontNum);
    l_buf[l_bufLen++] = GetDecimalToHex(rearNum);
  }
  Serial.write(l_buf, 8);
}

 

 

Dynamic Web Project가 필요하다.

새로 만들어도되고 기존의 것을 이용해도 된다.

그리고 시리얼 통신 설정이 되어있어야 한다.

RFID의 값을 시리얼 통신으로 자바로 넘겨받는 부분을 약간 손질할 것이다.

src폴더에 serial 패키지와 websocket 패키지 이렇게 2개를 만들자.

serial패키지에 들어있을 내용이다.

Main.java

ProcessRFID.java

Serial.java

SerialRead.java

SerialWebsocket.java

WebsocketClientArduino.java

 

websocket 패키지에 들어있을 내용이다.

WSocket.java

 

serial패키지의 내용부터 보자.

Main.java

시리얼 통신에서 다룬 내용과 같다. 대신 포트번호는 컴퓨터 혹은 USB마다 달라질 수 있으므로

반드시 포트번호에 맞게 설정한다.

 

Main.java 의 전체 내용

package serial;

public class Main {
	public static void main(String[] args) 
	{
		try {
			
			(new Serial()).connect("COM6");
		}
		catch(Exception e) 
		{
			e.printStackTrace();
		}
	}
}

 

 

Serial.java

기존의 SerialRead클래스에서 생성자에서 InputStream 하나의 변수만 넘겨받았는데,

여기서는 OutputStream 변수도 같이 넘겨받고 있다. 그 이유는 

데이터를 서버에 전송하는 ProcessRFID 클래스가 필요하기 때문에 그렇다.

 

Serial.java 의 전체 내용

package serial;
import java.io.InputStream;
import java.io.OutputStream;
import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;

public class Serial 
{
	void connect(String port) 
	{
		CommPort commPort = null;
		SerialPort serialPort = null;
		
		try 
		{
			CommPortIdentifier com = CommPortIdentifier.getPortIdentifier(port);
			
			//	com포트를 확인하는 작업
			if (com.isCurrentlyOwned())
				System.out.println("Error : "+port +"포트를 사용중입니다.");
			
			//	포트가 열려있으면
			else
			{
				commPort = com.open(this.getClass().getName(),1000);
				
				//	획득한 포트를 객체가 사용할 수 있는지 여부 확인
				if (commPort instanceof SerialPort)	//	commPort가 SerialPort로 사용할 수 있는지 확인
				{
					serialPort = (SerialPort)commPort;
					
					//	정상적으로 포트를 사용할 수 있을 경우
					//	포트에 필요한 정보를 입력해 준다.
					serialPort.setSerialPortParams(
							9600,						//	바운드레이트 
							SerialPort.DATABITS_8, 
							SerialPort.STOPBITS_1, 
							SerialPort.PARITY_NONE);	//	오류제어 비트
				}
				System.out.println("comport성공");
				
				InputStream in = serialPort.getInputStream();
				OutputStream out = serialPort.getOutputStream();
				
				(new Thread(new SerialRead(in, out))).start();
				(new Thread(new SerialWebsocket(out))).start();
			}
		}	//	end try
		catch(Exception e) {}
	}
}

 

 

SerialRead.java

SerialRead에서는 아두이노로부터 받은 데이터들을 받아서 읽은 값이 RFID 키값인지를 확인한 후에

ProcessRFID클래스의 SendReceivedDataToWebSocket메소드를 통해 서버로 데이터를 전송한다.

package serial;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class SerialRead implements Runnable
{
	InputStream in;
	private OutputStream out;
	
	boolean dataReceiveOk = false;
	boolean dataReceiveComplete = false;
	String receivedData = "";
	
	public SerialRead(InputStream in, OutputStream out)
	{
		this.in = in;
		this.out = out;
	}
	
	@Override
	public void run() 
	{
		byte[] buffer = new byte[1024];
		int len = -1;
		
		try {
			String s = "";
			//	buffer에 저장하고나서, 그 길이를 반환한다.
			while ((len = this.in.read(buffer)) > -1)
			{
				s = new String( buffer, 0, len );
				
				if ( s.length() == 0 && this.dataReceiveOk == true )
					this.dataReceiveComplete = true;
				
				if ( s.length() > 0 && this.dataReceiveComplete == false ) 
				{
					receivedData += s;
					this.dataReceiveOk = true;
				}
				else if ( this.dataReceiveComplete )
				{
					System.out.println("receivedData : " +this.receivedData);
					
					//	읽은 데이터가 카드정보이면, 카드 정보를 웹 서버에 전송
					if ( ProcessRFID.IsMatchedRFID(this.receivedData) )
					{
						System.out.println("카드 정보 입니다.");
						(new ProcessRFID(in, out)).SendReceivedDataToWebSocket(receivedData);
					}
					
					//	정보 초기화
					this.receivedData = "";
					this.dataReceiveComplete = false;
					this.dataReceiveOk = false;
				}
			}
		} 
		catch (IOException e) {e.printStackTrace();}
	}
}

 

 

ProcessRFID.java

ProcessRFID 클래스에는 RFID에 대한 카드 정보와 그에 따라 각 카드의 정보를 리턴하는 메소드들이 정의 되어 있고

ProcessRFID 클래스는 SendReceivedDataToWebSocket메소드를 통해 서버에 데이터를 전송하는 메소드이다.

그렇기 때문에 서버에 접속하는 내용이 있어야 한다.

그 부분이 생성자에서 정의 된다.

WebsocketClientArduino클래스에서 OutputStream을 요구하기 때문에, 이를 Serial.java에서 넘겨받는다.

그리고 서버에 실질적으로 접속하는 부분이 바로 아래의 부분이다.

그리고, SendReceivedDataToWebSocket메소드에서 ws의 메소드를 통해 서버로 데이터를 전송한다.

 

package serial;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.WebSocket;
import java.util.concurrent.CountDownLatch;

public class ProcessRFID 
{
	private InputStream in;
	private OutputStream out;
	private CountDownLatch latch;
	private WebSocket ws;
								
	//									흰색 카드		파란 카드, 	
	public static String[] RFIDs = { "97A8B64E", "C799FF32"}; 
	
	public ProcessRFID(InputStream in, OutputStream out) 
	{
		this.in = in;
		this.out = out;
		latch = new CountDownLatch(10);	//	데이터를 10번만 받겠다는 의미
		URI uri = URI.create("ws://localhost:9090/websocket"); 
		//	WebsocketClientArduino 클래스의 onText함수가 호출이 된다.
		WebsocketClientArduino listener = new WebsocketClientArduino( this.latch, this.out );
		
		ws = HttpClient.newHttpClient().newWebSocketBuilder().buildAsync(
				uri, listener).join();
	}
	
	//	파란 카드이면 true를, 흰색 카드이면 false를 리턴
	public static boolean IsMatchedBlueCard(String receivedData)
	{
		if ( RFIDs[0].equals(receivedData) )
			return false;
		else
			return true;
	}
	
	public static boolean IsMatchedRFID(String receivedData)
	{
		boolean ret = false;
		
		for ( String s : RFIDs)
		{
			if ( s.equals(receivedData))
			{
				ret = true;
				break;
			}
		}
		return ret;
	}
	
	private String GetCardInfo(String receivedData)
	{
		String ret = "";
		
		if (receivedData.equals(RFIDs[0]))
			ret = "흰색카드";
		else if (receivedData.equals(RFIDs[1]))
			ret = "파란카드";
		else
			ret = "정의되지않음";
		
		return ret;
	}
	
	public void SendReceivedDataToWebSocket(String receivedData)
	{
        System.out.println("카드 유형 : " +this.GetCardInfo(receivedData));
        
        ws.sendText(receivedData, true);
	}
}

 

 

WebsocketClientArduino.java

아래의 메소드는 서버가 받은 데이터를 뿌려줄 때 호출되는 함수이다.

여기서 우리는 흰색 카드이면 '1'을 전송하고 파란색 카드이면 '0'을 전송해서 LED를 On/Off 제어할 것이다.

 

package serial;

import java.io.IOException;
import java.io.OutputStream;
import java.net.http.WebSocket;
import java.net.http.WebSocket.Listener;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.CountDownLatch;

//	자바에서 지원하는 기본적인 소켓을 만든 것이다.
//	WebSocket.Listener를 통해, 웹 소켓에 접속할 것이다.
public class WebsocketClientArduino implements WebSocket.Listener
{
	//	웹 소켓에서 전송되는 데이터 수를 정하는 변수
	//	만약, 3번만 데이터를 수신하고 싶으면 3으로 설정
	//	웹 소켓이 닫히게 된다. onClose함수가 자동으로 실행된다.
	private final CountDownLatch latch;	//	몇번을 받을 것인가?
	private OutputStream out;
	
	//	사용할 횟수만큼 매개변수로 전달하면 된다.
	public WebsocketClientArduino( CountDownLatch latch, OutputStream out) {
		this.latch = latch;
		this.out = out;
	}
	
	@Override
	//	서버에 접속했을 때, 호출된다.
	public void onOpen(WebSocket webSocket) {
		System.out.println("arduino websocket open");
		Listener.super.onOpen(webSocket);
	}
	
	@Override
	public CompletionStage<?> onClose(WebSocket webSocket, int statusCode, String reason) {
		System.out.println("arduino websocket close");
		return Listener.super.onClose(webSocket, statusCode, reason);
	}
	
	@Override
	public void onError(WebSocket webSocket, Throwable error) {
		System.out.println("arduino websocket error");
		Listener.super.onError(webSocket, error);
	}
	
	@Override
	//	메시지(텍스트)가 도착했을 때, 호출되는 함수
	public CompletionStage<?> onText(WebSocket webSocket, CharSequence data, boolean last) {
		System.out.println("WebsocketClientArduino 클래스의 onText 메소드 호출 => "+"arduino recv message : " +data);
		this.latch.countDown();		
		
		byte led;
		
		//	파란카드이면 true, 흰색카드이면 false
		if ( ProcessRFID.IsMatchedBlueCard(data.toString()) )	led = '1';
		else       												led = '0';
		
		try {this.out.write(led);} 
		catch (IOException e) {e.printStackTrace();}
		
		return Listener.super.onText(webSocket, data, last);
		/*
		try {this.out.write(data.toString().getBytes());} 
		catch (IOException e) {e.printStackTrace();}
		
		return Listener.super.onText(webSocket, data, last);
		*/
	}
}

 

 

SerialWebsocket.java

SerialWebsocket 클래스는 Serial.java에서 다음과 같이 호출되는 클래스이다.

즉, 아두이노로 데이터를 보내는 역할을 하는 것이 SerialWebsocket 클래스가 하는 일이다.

 

SerialWebsocket.java 의 전체 내용

package serial;
import java.io.OutputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.WebSocket;
import java.util.concurrent.CountDownLatch;

public class SerialWebsocket implements Runnable 
{
	OutputStream out;
	
	//	Constructor
	public SerialWebsocket(OutputStream out) {this.out = out;}
	
	@Override
	public void run() {
		try {
			CountDownLatch latch = new CountDownLatch(10);	//	데이터를 10번만 받겠다는 의미
			URI uri = URI.create("ws://localhost:9090/websocket");
			WebsocketClientArduino listener = new WebsocketClientArduino(latch, out);
			
			WebSocket ws = HttpClient.newHttpClient().newWebSocketBuilder().buildAsync(
					uri, listener).join();
			
			ws.sendText("java app sendmessage", true);
			latch.await();
	
		}catch(Exception e) { e.printStackTrace();	}
	}
}

 

 

websocket패키지의 내용을 보자.

WSocket.java

package websocket;

import java.util.Collections;
import java.util.Set;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.RemoteEndpoint.Basic;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint("/websocket")
public class WSocket 
{
	private static final Set<Session> sessions = Collections.synchronizedSet(
			new java.util.HashSet<Session>()
			);
	
	//	onopen 이벤트가 호출 되면 실행되는 함수
	@OnOpen
	public void handleOpen(Session session)
	{
		System.out.println("클라이언트가 접속했습니다.");
		System.out.println("WSocket 클래스의 handleOpen 메소드 호출 => " +"session id : " +session.getId());
		sessions.add(session);
	}
	/*
	//	onclose 이벤트가 호출 되면 실행되는 함수
	@OnClose
	public void handleClose()
	{
		System.out.println("클라이언트가 연결을 해제했습니다.");
	}
	*/
	//	onclose 이벤트가 호출 되면 실행되는 함수
	@OnClose
	public void handleClose(Session session)
	{
		System.out.println(session.getId() + "클라이언트가 연결을 해제했습니다.");
		
		//	세션을 닫는다.
		sessions.remove(session);
	}
	
	//	onerror 이벤트가 호출 되면 실행되는 함수
	@OnError
	public void handleError(Throwable t)
	{
		t.printStackTrace();
	}
	
	//	onmessage 이벤트가 호출 되면 실행되는 함수
	@OnMessage
	public void handleMessage(String message, Session session)
	{
		//	서버가 받는다.
		System.out.println("WSocket 클래스의 handleMessage 메소드 호출 => " +"클라이언트가 보내온 메시지 : " +message);
		//	System.out.println(message);
		
		this.sendAll(session, message);
		
		try {
			final Basic basic = session.getBasicRemote();
			basic.sendText(message);
		}catch(Exception e) {}
	}
	
	public void sendAll(Session session, String message)
	{
		System.out.println("WSocket 클래스의 sendAll 메소드 호출 => " + session.getId() + " : " +message);
		try {
			int i = 0;
			//	웹 소켓에 연결되어 있는 모든 아이디를 찾는다.	
			for (Session s : WSocket.sessions) 
			{
				System.out.println(++i);
				if (!s.getId().equals(session.getId()))
				{
					s.getBasicRemote().sendText(message);
				}
			}
		}catch(Exception e) {e.printStackTrace();}
	}
}

 

 

아래는 서버를 실행하고 나서, Main.java를 실행했을 때의 콘솔 창의 실행결과이다.

 

파란색 카드를 찍었을 때이다. LED는 켜진다.

 

그리고 뒤이어 흰색 카드를 찍었을 때이다. LED는 꺼진다.

 

그리고 나서 서버만 종료를 하면 콘솔 화면 창이 다음과 같은 결과가 뜬다.

 

프로젝트의 전체 내용

WebSocketRFID.war

0.18MB

 

 

 

그리고, 위의 내용에서 한 가지 이상한 점이 있다.

파란색 혹은 흰색 카드를 찍었을 뿐인데, 세션이 증가하는 것을 볼 수 있다.

이는 약간 이상하다.

 

serial 패키지의 SerialWebsocket.java를 보자.

 

위의 클래스에서 변경한 부분은 생성자에 10을 전달했는데, 이를 1로 변경한다.

그리고 sendText 메소드의 두 번째 매개변수를 false로 변경한다.

 

 

그리고, websocket 패키지의 WSocket.java로 이동하자.

아래의 handleMessage 메소드에서 데이터를 뿌리고 나서, 해당 세션의 연결을 해제한다.

즉, session.close() 메소드를 호출한다.

 

아래는 디버깅용으로 세션의 수를 출력한다.

 

아래는 디버깅용으로 세션의 수를 출력한다.

 

그리고 다시 실행해보자.

서버를 실행시키고 나서, Main.java를 실행시키자.

 

아래는 서버를 실행하고 Main.java를 실행했을 때의 실행결과 화면이다.

 

아래는 파란카드를 찍었을 때이다. 세션이 해제가 되어 현재의 세션의 개수가 1개임을 알 수 있다.

그리고 LED가 On이 되는 것을 볼 수 있다.

 

그리고 다시 흰색 카드를 찍어보면 아래와 같다.

그리고 LED가 Off가 되는 것을 볼 수 있다.

 

그리고 다시, 파란 카드를 찍었을 때이다.

세션은 1개임을 알 수 있다. 

 

그러면 여기서 한 가지 궁금한 것이 있다.

세션은 언제 증가하는가 이다.

이를 위해서 websocket 패키지에 webcontroller.java 파일을 만든다.

이는 컨트롤러이다.

webcontroller.java

package websocket;

import java.io.IOException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@WebServlet("/websocketcomm")
public class webcontroller extends HttpServlet
{
	private static final long serialVersionUID = 1L;

	protected void service(HttpServletRequest request, HttpServletResponse response) 
			throws ServletException, IOException 
	{
				HttpSession session = request.getSession();
				//페이지를 전송하기 전에 url을 분석하고 비교해서 실행
				String url = request.getRequestURI();
				//System.out.println("url : "+url);
				String contextPath = request.getContextPath();
				//System.out.println("contextpath : "+contextPath);
				String path = url.substring(contextPath.length());
				//System.out.println("path : "+path);
				//마지막 '/'를 기준으로 값 추출
				String lastPath = url.substring(url.lastIndexOf('/')+1);
				System.out.println("subPath : "+ lastPath);
				//최종 주소
				String command = lastPath;
				
				if(command.equals("led")) 
				{	
					RequestDispatcher dispatcher = 
							request.getRequestDispatcher("/WEB-INF/arduinoled.jsp");
					dispatcher.forward(request, response);
				}
				else 
				{
					RequestDispatcher dispatcher = 
							request.getRequestDispatcher("/WEB-INF/arduinoled.jsp");
					dispatcher.forward(request, response);
				}
	}
}

 

그리고 WEB-INF폴더에 jsp파일을 하나 만든다.

arduinoled.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>

rfid 값을 받으면
<body>
<button onclick="ws.send('u')">servo plus</button><p>
<button onclick="ws.send('d')">servo minus</button><p>

<input type="range" id="vol" name="vol" min="0" max="180" onchange="ws.send(this.value)">
 
<script>
	var ws = new WebSocket("ws://localhost:9090/websocket");
	
	ws.onopen = function() {console.log('open')}
	
	ws.onmessage = function(event) { console.log(event.data);}
	
	ws.onopen = function(event) {console.log('close')}
	
	ws.onopen = function(event) {console.log('error')}
	
	ws.onmessage = function(event) { console.log();}
</script>

</body>
</html>

 

 

다시 서버를 재실행시키고, Main.java를 실행시키자.

이번에는 웹 페이지를 하나 열고, http://localhost:9090/websocketcomm로 접속하자.

그리고 콘솔 화면 창을 보자.

 

그리고 다시 새 웹 페이지를 하나 열고 다시 http://localhost:9090/websocketcomm로 접속하자.

아래와 같이 세션이 하나 증가함을 알 수 있다.

이와 같이 접속할 때마다 세션은 증가한다.

 

다시 파란 카드를 찍어보자. LED는 당연히 켜진다.

세션의 개수가 3개로 유지되는 것을 볼 수 있다.

 

여기서, 웹 페이지 창을 하나씩 종료 해보자.

기존의 3개의 세션에서 하나가 감소한 것을 알 수 있다.

 

다시, 웹 페이지 창을 하나 종료 해보자.

세션이 다시 하나 감소한 것을 알 수 있다.

 

그리고 다시 새 웹 페이지를 하나 열고 다시 http://localhost:9090/websocketcomm로 접속하자.

아래와 같이 세션이 하나 증가함을 알 수 있다.

 

그리고, websocket 패키지의 WSocket.java에서 sendAll 메소드를 보자.

다음과 같이 주석처리를 해놓고 다시 실행해서 그 결과를 살펴보자.

 

서버를 실행시키고, Main.java를 실행시키자.

아래는 파란 카드를 찍었을 때의 결과이다. LED는 당연히 On이 된다.

 

흰색 카드를 찍어보자. 아래와 같이 세션은 그대로 1개이다.

LED는 당연히 Off 된다.

 

그리고 다시 새 웹 페이지를 하나 열고 다시 http://localhost:9090/websocketcomm로 접속하자.

아래와 같이 세션이 하나 증가함을 알 수 있다.

 

그리고 다시 새 웹 페이지를 하나 열고 다시 http://localhost:9090/websocketcomm로 접속하자.

아래와 같이 세션이 하나 증가함을 알 수 있다.

 

웹 페이지를 하나 종료해보자.

세션이 하나 감소되었음을 볼 수 있다.

 

파란 카드를 찍어보자. 

세션은 그대로 2개이다. LED는 On이다.

 

마지막으로 웹 페이지를 닫아보자.

다음과 같이 세션이 하나 감소했다.

 

프로젝트 내용

WebSocketRFID.war

0.18MB