Обмен данными между Java-приложением и МК. Часть 1. По проводу, USB-UART

#ifndef ONEWIRE_H_
#define ONEWIRE_H_

#define F_CPU             8000000UL

#include <util/delay.h>
#include <avr/io.h>

#define DELAY_A           6
#define DELAY_B           64
#define DELAY_C           60
#define DELAY_D           10
#define DELAY_E           9
#define DELAY_F           55
#define DELAY_G           0
#define DELAY_H           480
#define DELAY_I           70
#define DELAY_J           410

#define MSBit             0x80
#define LSBit             0x01

#define OWI_DDR           DDRB
#define OWI_PIN           PINB
#define OWI_BUS           PB0
#define OWI_RELEASE_BUS   OWI_DDR &= ~(1 << OWI_BUS)
#define OWI_PULL_BUS_LOW  OWI_DDR |= (1 << OWI_BUS)

void owiInit();
void owiReset();
void owiWriteBit0();
void owiWriteBit1();
unsigned char owiReadBit();
void owiSendByte(unsigned char data);
unsigned char owiReceiveByte();

#endif /* ONEWIRE_H_ */

#include "OneWire.h"

void owiInit()
{
  OWI_RELEASE_BUS;
  _delay_us(DELAY_H);
}

void owiReset()
{
  OWI_PULL_BUS_LOW;
  _delay_us(DELAY_H);  
  OWI_RELEASE_BUS;
  _delay_us(DELAY_I);  
  _delay_us(DELAY_J);
}

void owiWriteBit0()
{
  OWI_PULL_BUS_LOW;
  _delay_us(DELAY_C);
  OWI_RELEASE_BUS;
  _delay_us(DELAY_D);  
}

void owiWriteBit1()
{
  OWI_PULL_BUS_LOW;
  _delay_us(DELAY_A);
  OWI_RELEASE_BUS;
  _delay_us(DELAY_B);    
}

unsigned char owiReadBit()
{
  uint32_t bitsRead = 0;
  OWI_PULL_BUS_LOW;
  _delay_us(DELAY_A);  
  OWI_RELEASE_BUS;
  _delay_us(DELAY_E);  
  if(OWI_PIN & (1 << OWI_BUS)) 
      bitsRead = 1;  
  _delay_us(DELAY_F);  
    return bitsRead;
}

void owiSendByte(unsigned char data)
{
  unsigned char temp, currentBit;

  for (currentBit = 0; currentBit < 8; currentBit++) 
  {
    temp = data & 0x01;
    if (temp) 
    {
      owiWriteBit1();
    } 
    else 
    {
      owiWriteBit0();
    }
    data >>= 1;
  }  
}

unsigned char owiReceiveByte()
{
  unsigned char data = 0, currentBit = 0;  

  for (currentBit = 0; currentBit < 8; currentBit++) 
  {  
    data >>= 1;
    if (owiReadBit()) 
    {
      data |= MSBit;
    }
  }
  return data;    
}

#ifndef DS18B20_H_
#define DS18B20_H_

#include "OneWire.h"

#define SKIP_ROM            0xCC
#define READ_SCRATCH_PAD    0xBE
#define CONVERT_T           0x44

#define CONVERT_DELAY       750

#define MINUS               1
#define PLUS                0

#define SIGN_BITS           0xf8

void DS18B20_Init();
float DS18B20_ReadTemperature();
unsigned char data[2];
extern unsigned char temperatureSign;

#endif /* DS18B20_H_ */

#include "DS18B20.h"

unsigned char temperatureSign;

void DS18B20_Init()
{
  owiInit();
}

float DS18B20_ReadTemperature()
{
  owiReset();
  owiSendByte(SKIP_ROM);
  owiSendByte(CONVERT_T);
  _delay_ms(CONVERT_DELAY);

  owiReset();
  owiSendByte(SKIP_ROM);
  owiSendByte(READ_SCRATCH_PAD);
  for(int i = 0; i < 2; i++)
  {
    data[i] = owiReceiveByte();
  }
  owiReset();

  float temperature = (data[1] << 8 | data[0])/16.0;
  if(temperature >= 0)
  {
    temperatureSign = PLUS;
  }
  else if(temperature < 0)
  {
    temperatureSign = MINUS; 
  }

  return temperature;
}

#ifndef TIMER_H_
#define TIMER_H_

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>

void timerInit();

extern volatile uint8_t timerFlag;

#endif /* TIMER_H_ */

#include "timer.h"

volatile uint8_t timerFlag = 0;

ISR(TIMER1_OVF_vect) 
{
  timerFlag = 1;
}

void timerInit() 
{
  TCCR1A = 0;
  /* Разрешить локально прерывание по переполнению счётчика */
  TIMSK1 = (1 << TOIE1);
  /* Разрешить прерывания глобально */
  sei();
  /* Включить тактирование таймера с делителем 256 */
  TCCR1B = (1 << CS12);
}

SREG   = 0x3f    
OUTBIT = 5 /* управляющий пин - PC5 */
PORTC  = 0x08

  .text
    .global stripRefresh
    stripRefresh:
      movw  r26, r24            /* сохранить адрес буфера grbValue в пару r26-r27 */
      movw  r24, r22            /* сохранить количество элементов буфера grbValue в пару r24-r25 */
      in    r22, SREG           /* сохранить текущее состояние регистра SREG */
      cli                       /* запретить глобально прерывания */
      in    r20, PORTC
      ori   r20, (1 << OUTBIT)  /* сохранить маску бинарного "1" - в r20 */
      in    r21, PORTC
      andi  r21, ~(1 << OUTBIT) /* сохранить маску бинарного "0" - в r21 */
      ldi   r19, 7              /* r19 - счётчик записи первых 7 битов */
      ld    r18, X+             /* скопировать в r18 первый элемент буфера grbValue */
    loop1:
      out   PORTC, r20          /* 1    +0   установить PC5 в 1 */
      lsl   r18                 /* 1    +1   сдвинуть старший бит r18 в бит С регистра SREG */
      brcs  L1                  /* 1/2  +2   если старший бит r18 - 1, перейти к метке L1 */
      out   PORTC, r21          /* 1    +3   сбросить PC5 в 0 (итого - три такта в состоянии High) */
      nop                       /* 1    +4 */
      bst   r18, 7              /* 1    +5   сохранить 7-й бит r18 в бит Т регистра SREG для последующей проверки */
      subi  r19, 1              /* 1    +6   декрементировать r19 */
      breq  bit8                /* 1/2  +7   если в WS2812B записан 7-й бит перейти к метке bit8 для записи 8-го бита */
      rjmp  loop1               /* 2    +8   итого - 10 тактов на запись бинарного "0" */
    L1:
      nop                       /* 1    +4 */
      bst   r18, 7              /* 1    +5   сохранить 7-й бит r18 в бит Т регистра SREG для последующей проверки */
      subi  r19, 1              /* 1    +6   декрементировать r19 */
      out   PORTC, r21          /* 1    +7   сбросить PC5 в 0 (итого - 7 тактов в состоянии High) */
      brne  loop1               /* 2/1  +8   итого - 10 тактов на запись бинарного "1" */
    bit8:
      ldi   r19, 7              /* 1    +9   обновить счётчик битов */
      out   PORTC, r20          /* 1    +0   установить PC5 в 1 */
      brts  L2                  /* 1/2  +1   если последний бит текущего элемента буфера grbValue - 1, перейти к метке L2 */
      nop                       /* 1    +2 */
      out   PORTC, r21          /* 1    +3   сбросить PC5 в 0 (итого - три такта в состоянии High) */
      ld    r18, X+             /* 2    +4   загрузить следующий элемент буфера grbValue */
      sbiw  r24, 1              /* 2    +6   декрементировать счётчик элементов буфера grbValue */
      brne  loop1               /* 2    +8   если записаны не все элементы, перейти к метке loop1 */
      out   SREG, r22           /* восстановить значение регистра SREG */
      ret
    L2:
      ld    r18, X+             /* 2    +3   загрузить следующий элемент буфера grbValue */
      sbiw  r24, 1              /* 2    +5   декрементировать счётчик элементов буфера grbValue */
      out   PORTC, r21          /* 1    +7   сбросить PC5 в 0 (итого - 7 тактов в состоянии High) */
      brne  loop1               /* 2    +8   если записаны не все элементы, перейти к метке loop1 */
      out   SREG, r22           /* восстановить значение регистра SREG */
      ret
.end

#ifndef STRIP_H_
#define STRIP_H_

#include <avr/io.h>
#include <stdint.h>
#include <string.h>

#define STRIP_LENGTH  9
#define GRB_NUM       (STRIP_LENGTH * 3)

#define STRIP_DDR     DDRC
#define STRIP_PIN     PC5
#define STRIP_OFF     0
#define STRIP_ON      1

void stripOff();
void stripSetColor();
void setLedColor(uint8_t* buf, uint8_t ledNum, uint8_t green, uint8_t red, uint8_t blue);

extern void stripRefresh(uint8_t* buf, uint16_t grbNum);

extern uint8_t grbValue[GRB_NUM];
extern uint8_t redValue, greenValue, blueValue;

#endif /* STRIP_H_ */

#include "strip.h"

uint8_t grbValue[GRB_NUM];
uint8_t	stripState = STRIP_OFF;

uint8_t redValue, greenValue, blueValue;

void stripOff()
{
  memset(grbValue, 0, sizeof(grbValue));
  stripRefresh(grbValue, sizeof(grbValue));
}

void stripSetColor()
{
  for(uint8_t ledNum = 0; ledNum < STRIP_LENGTH; ledNum++)
  {
    setLedColor(grbValue, ledNum, greenValue, redValue, blueValue);
  }
  stripRefresh(grbValue, sizeof(grbValue));
}

void setLedColor(uint8_t* buf, uint8_t ledNum, uint8_t green, uint8_t red, uint8_t blue)
{
  uint16_t index = 3 * ledNum;
  grbValue[index++] = red;
  grbValue[index++] = green;
  grbValue[index] = blue;
}

#ifndef SERIAL_H_
#define SERIAL_H_

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>
#include <stdbool.h>

#define UART_BAUDRATE  9600
#define FREQUENCY      8000000UL
#define UBRR_VALUE     FREQUENCY / 16 / UART_BAUDRATE - 1

void serialBegin();
void serialPrintln(const uint8_t* buff);
void serialSendByte(uint8_t symbol);

extern volatile uint8_t receivedByte[4];
extern volatile bool receiveFlag;

#endif /* SERIAL_H_ */

#include "Serial.h"

volatile uint8_t receivedByte[4], byteNum = 0;
volatile bool receiveFlag;

ISR(USART_RX_vect)
{
  receivedByte[byteNum] = UDR0;
  byteNum++;
  if(byteNum > 3)
  {
    byteNum = 0;
    receiveFlag = 1;
  }  
}

void serialBegin()
{
  uint16_t ubrrValue = UBRR_VALUE;

  UBRR0H = (uint8_t)(ubrrValue >> 8);
  UBRR0L = (uint8_t)(ubrrValue);
  UCSR0B |= (1 << TXEN0) | (1 << RXEN0) | (1 << RXCIE0);
  UCSR0C |= (3 << UCSZ00);
  sei();
}

void serialSendByte(uint8_t data)
{
  while (!(UCSR0A & (1 << UDRE0)));
  UDR0 = data;
}

void serialPrintln(const uint8_t* buff)
{
  while(*buff != '\0')
  {
    serialSendByte(*buff);
    buff++;
  }
  serialSendByte('\n');
}

#ifndef DEVICE_H_
#define DEVICE_H_

#include "Serial.h"
#include "DS18B20.h"
#include "timer.h"
#include "strip.h"

#define KEY  87        

void deviceInit();
void deviceControl();

#endif /* DEVICE_H_ */

#include "device.h"

void deviceInit()
{
  serialBegin(); 
  STRIP_DDR |= (1 << STRIP_PIN); 
  stripOff();
  DS18B20_Init();
  timerInit();
}

void deviceControl()
{
  if(receiveFlag)
  {
    receiveFlag = 0;
    if(receivedByte[0] == KEY)
    {
      redValue = receivedByte[1];
      greenValue = receivedByte[2];
      blueValue = receivedByte[3];
      stripSetColor();
    }	
  }

  if(timerFlag)
  {
    uint8_t temperatureBuff[4];
    timerFlag = 0;
    float currentTemperature = DS18B20_ReadTemperature();

    if(temperatureSign == PLUS)
    {
      temperatureBuff[0] = 0;
    }
    else if(temperatureSign == MINUS)
    {
      temperatureBuff[0] = 1;
    }

    temperatureBuff[1] = (uint8_t)(currentTemperature / 10);
    temperatureBuff[2] = (uint8_t)(currentTemperature - temperatureBuff[1] * 10);
    temperatureBuff[3] = (uint8_t)(currentTemperature * 10 - temperatureBuff[1] * 100 - temperatureBuff[2] * 10);
    for(int byteNum = 0; byteNum < 4; byteNum++)
    {
      serialSendByte(temperatureBuff[byteNum]);
    }	
  }
}

import javax.swing.*;   
import java.awt.*;  
import java.awt.event.*;  
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.plaf.ColorUIResource;
import com.fazecast.jSerialComm.SerialPort;

public class MyFrame implements ActionListener, ChangeListener {
  Font MyFont;
  boolean OPEN = true;
  boolean CLOSE = false;
  boolean openCloseButtonFunction = OPEN;
  boolean openCloseButtonFlag = false;
  boolean slidersFlag = false;
  JFrame MyFrame;       
  JComboBox<String> comPortBox, baudRateBox, dataBitsBox, stopBitsBox, parityBitsBox;
  JButton openCloseButton;
  JLabel temperatureValueLabel, celsiusLabel;
  JSlider redColorSlider, greenColorSlider, blueColorSlider;    
  JTextField colorField;    
  SerialPort []portList;

  MyFrame() {  
    MyFont = new Font("Ink Free", Font.BOLD, 15);
    MyFrame = new JFrame("Led control"); 
    MyFrame.setResizable(false);
    MyFrame.setLayout(null);    
    MyFrame.setSize(440, 500); 
    baudRateComponentsInit();
    dataBitsComponentsInit();
    stopBitsComponentsInit();
    parityBitsComponentsInit();
    comPortComponentsInit();
    openCloseButtonInit();
    redSliderComponentsInit();
    greenSliderComponentsInit();
    blueSliderComponentsInit();
    colorFieldInit();
    temperatureComponentsInit();
    MyFrame.setVisible(true);    
  }
    
  private void baudRateComponentsInit() {
    JLabel baudRateLabel;
    baudRateLabel = new JLabel("Baud rate");  
    baudRateLabel.setFont(MyFont);
    baudRateLabel.setBounds(90, 20, 100,30); 
    MyFrame.add(baudRateLabel);
    
    String baudRate[]={"4800", "9600", "14400", "19200", "28800", "38400", "57600", "115200"};  
    baudRateBox = new JComboBox<>(baudRate);  
    baudRateBox.setBounds(73, 45, 100, 30);   
    baudRateBox.setEnabled(true);
    baudRateBox.setFont(MyFont);
    baudRateBox.setSelectedItem("9600");
    MyFrame.add(baudRateBox);
  }

  private void dataBitsComponentsInit() {
    JLabel dataBitsLabel;
    dataBitsLabel = new JLabel("Data bits");  
    dataBitsLabel.setFont(MyFont);
    dataBitsLabel.setBounds(223, 20, 100,30);
    MyFrame.add(dataBitsLabel);
   
    String dataBits[]={"5", "6", "7", "8"};  
    dataBitsBox = new JComboBox<>(dataBits); 
    dataBitsBox.setBounds(205, 45, 100, 30); 
    dataBitsBox.setEnabled(true);
    dataBitsBox.setFont(MyFont);
    dataBitsBox.setSelectedItem("8");
    MyFrame.add(dataBitsBox);
  }

  private void stopBitsComponentsInit() {
    JLabel stopBitsLabel;
    stopBitsLabel = new JLabel("Stop Bits");  
    stopBitsLabel.setFont(MyFont);
    stopBitsLabel.setBounds(90, 95, 100,30);
    MyFrame.add(stopBitsLabel);
    
    String stopBits[]={"1", "1.5", "2"};
    stopBitsBox = new JComboBox<>(stopBits);
    stopBitsBox.setBounds(73, 120, 100, 30);
    stopBitsBox.setFont(MyFont);
    stopBitsBox.setEnabled(true);
    MyFrame.add(stopBitsBox);
  }

  private void parityBitsComponentsInit() {
    JLabel parityBitsLabel;
    parityBitsLabel = new JLabel("Parity Bits");  
    parityBitsLabel.setFont(MyFont);
    parityBitsLabel.setBounds(220, 95, 100,30);
    MyFrame.add(parityBitsLabel);
    
    String parityBits[]={"none", "odd", "even", "mark", "space"};  
    parityBitsBox = new JComboBox<>(parityBits);
    parityBitsBox.setBounds(205, 120, 100,30);    
    parityBitsBox.setFont(MyFont); 
    parityBitsBox.setEnabled(true);
    MyFrame.add(parityBitsBox);
  }

  private void comPortComponentsInit() {
    JLabel comPortLabel;
    comPortLabel = new JLabel("COM port");  
    comPortLabel.setFont(MyFont);
    comPortLabel.setBounds(90, 170, 100,30);
    MyFrame.add(comPortLabel);
    
    comPortBox = new JComboBox<>(); 
    comPortBox.setFont(MyFont);
    comPortBox.setBounds(73, 195, 100,30);  
    portList = SerialPort.getCommPorts();
    for (SerialPort port: portList) {
      comPortBox.addItem(port.getSystemPortName());
    }
    MyFrame.add(comPortBox);
  }

  private void openCloseButtonInit() {
    openCloseButton = new JButton("Open");
    openCloseButton.setBounds(205, 195, 100,30);
    openCloseButton.setFocusable(false);
    openCloseButton.setFont(MyFont);
    openCloseButton.addActionListener(this);
    openCloseButton.setEnabled(true);
    MyFrame.add(openCloseButton);
  }

  private void redSliderComponentsInit() {
    JLabel redSliderLabel = new JLabel("R");
    redSliderLabel.setBounds(55, 250, 15, 15);
    redSliderLabel.setForeground(Color.RED);
    redSliderLabel.setFont(MyFont);
    MyFrame.add(redSliderLabel);

    redColorSlider = new JSlider(0, 255, 0);
    redColorSlider.setBounds(73, 240, 150, 40);
    redColorSlider.setValue(0);
    redColorSlider.setPaintLabels(true);
    redColorSlider.addChangeListener(this);
    MyFrame.add(redColorSlider);
  }

  private void greenSliderComponentsInit() {
    JLabel greenSliderLabel = new JLabel("G");
    greenSliderLabel.setBounds(55, 280, 15, 15);
    greenSliderLabel.setForeground(Color.GREEN);
    greenSliderLabel.setFont(MyFont);
    MyFrame.add(greenSliderLabel);

    greenColorSlider = new JSlider(0, 255, 0);
    greenColorSlider.setBounds(73, 270, 150, 40);
    greenColorSlider.setValue(0);
    greenColorSlider.setPaintLabels(true);
    greenColorSlider.addChangeListener(this);
    MyFrame.add(greenColorSlider);
  }

  private void blueSliderComponentsInit() {
    JLabel blueSliderLabel = new JLabel("B");
    blueSliderLabel.setBounds(55, 310, 15, 15);
    blueSliderLabel.setForeground(Color.BLUE);
    blueSliderLabel.setFont(MyFont);
    MyFrame.add(blueSliderLabel);

    blueColorSlider = new JSlider(0, 255, 0);
    blueColorSlider.setBounds(73, 300, 150, 40);
    blueColorSlider.setValue(0);
    blueColorSlider.setPaintLabels(true);
    blueColorSlider.addChangeListener(this);
    MyFrame.add(blueColorSlider);
  }

  private void colorFieldInit() {
    colorField = new JTextField();
    colorField.setBounds(235, 255, 70, 70);
    colorField.setBackground(new ColorUIResource(redColorSlider.getValue(), greenColorSlider.getValue(), blueColorSlider.getValue()));
    MyFrame.add(colorField);
  }

  private void temperatureComponentsInit() {
    temperatureValueLabel = new JLabel("00.0", SwingConstants.RIGHT);
    temperatureValueLabel.setFont(new Font("Ink Free", Font.BOLD, 35));
    temperatureValueLabel.setBounds(110, 365, 110, 100);
    temperatureValueLabel.setBackground(MyFrame.getBackground());
    MyFrame.add(temperatureValueLabel);

    celsiusLabel = new JLabel();
    celsiusLabel.setText("\u00B0" + "C");
    celsiusLabel.setFont(new Font("Ink Free", Font.BOLD, 35));
    celsiusLabel.setBounds(225, 365, 40, 100);
    celsiusLabel.setBackground(MyFrame.getBackground());
    MyFrame.add(celsiusLabel);
  }

  void showMessageDialog(String message) {
    JOptionPane.showMessageDialog(MyFrame, message);
  }

  @Override
  public void actionPerformed(ActionEvent e) {
    if(e.getSource() == openCloseButton) {
      openCloseButtonFlag = true;
    }
  }

  @Override
  public void stateChanged(ChangeEvent e) {
    if(e.getSource() == redColorSlider || e.getSource() == greenColorSlider || e.getSource() == blueColorSlider) {
      colorField.setBackground(new ColorUIResource(redColorSlider.getValue(), greenColorSlider.getValue(), blueColorSlider.getValue()));
      slidersFlag = true;   
    }
  }
}

import java.io.IOException;
import java.io.OutputStream;
import com.fazecast.jSerialComm.SerialPort;  
import com.fazecast.jSerialComm.SerialPortDataListener;  
import com.fazecast.jSerialComm.SerialPortEvent; 

public class MySerial {
  String dataBuffer = "";
  SerialPort currentComPort;
  final byte NO_FLAG = 0;
  final byte SUCCESS_TO_OPEN = 1;
  final byte FAIL_TO_OPEN = 2;
  final byte PLEASE_CHOOSE_COM_PORT = 3;
  final byte PORT_IS_CLOSED = 4;
  byte comPortPane = NO_FLAG;
  OutputStream stripStream;

  enum comPortPane {
    NO_FLAG,
    SUCCESS_TO_OPEN,
    FAIL_TO_OPEN,
    PLEASE_CHOOSE_COM_PORT,
    PORT_IS_CLOSED
  }

  void openPort() {
    try { 
      currentComPort.openPort();
      if(currentComPort.isOpen()) {
        comPortPane = SUCCESS_TO_OPEN;
        SerialEventBasedReading(currentComPort);
      }
      else {
        comPortPane = FAIL_TO_OPEN;
      }
    }
    catch(ArrayIndexOutOfBoundsException a) {
      comPortPane = PLEASE_CHOOSE_COM_PORT;
    }
    catch(Exception b) {
    }
  }

  void closePort() {
    if(currentComPort.isOpen()) {
      currentComPort.closePort();
      comPortPane = PORT_IS_CLOSED;
    }
  }

  void sendColorData(int redValue, int greenValue, int blueValue) {
    stripStream = currentComPort.getOutputStream();
    int[] dataToSend = new int[4];
    dataToSend[0] = 87;
    dataToSend[1] = redValue;
    dataToSend[2] = greenValue;
    dataToSend[3] = blueValue;
    try {
      stripStream.write(dataToSend[0]);
      stripStream.write(dataToSend[1]);
      stripStream.write(dataToSend[2]);
      stripStream.write(dataToSend[3]);
    }
    catch(IOException noSendException) {
    }
  }

  private void SerialEventBasedReading(SerialPort activePort) {
    activePort.addDataListener(new SerialPortDataListener() {
      @Override
      public int getListeningEvents() {
        return SerialPort.LISTENING_EVENT_DATA_RECEIVED;
      }

      @Override
      public void serialEvent(SerialPortEvent arg0) {
        byte []newData = arg0.getReceivedData();  
        if(newData.length == 4) {
          dataBuffer = "";
          if(newData[0] == 0) {
            dataBuffer = "+";
          }
          else if(newData[0] == 1) {
            dataBuffer = "-";
          }
          dataBuffer += newData[1];
          dataBuffer += newData[2];
          dataBuffer += ".";
          dataBuffer += newData[3];
        }
      }
    });
  }
}

import java.util.Timer;
import java.util.TimerTask;

public class Main {
  static int currentRedValue, currentGreenValue, currentBlueValue;

  public static void main(String[] args) {
    MyFrame frame = new MyFrame();
    MySerial serial = new MySerial();
      
    TimerTask timerTask = new TimerTask() {
      public void run() {
        if(frame.openCloseButtonFlag == true) {
          frame.openCloseButtonFlag = false;
          if(frame.openCloseButtonFunction == frame.OPEN) {
            serial.currentComPort = frame.portList[frame.comPortBox.getSelectedIndex()];
            serial.currentComPort.setBaudRate(Integer.parseInt(frame.baudRateBox.getSelectedItem().toString()));
            serial.currentComPort.setNumDataBits(Integer.parseInt(frame.dataBitsBox.getSelectedItem().toString()));
            serial.currentComPort.setNumStopBits(Integer.parseInt(frame.stopBitsBox.getSelectedItem().toString()));
            serial.currentComPort.setParity(frame.parityBitsBox.getSelectedIndex());
            serial.openPort();
            if(serial.comPortPane == serial.SUCCESS_TO_OPEN) {
              frame.openCloseButtonFunction = frame.CLOSE;
              frame.openCloseButton.setText("Close");
              frame.showMessageDialog("        Success to OPEN");                       
            }
            else {
              frame.showMessageDialog("            Fail to OPEN");
            }
          }
          else if(frame.openCloseButtonFunction == frame.CLOSE) {
            frame.openCloseButtonFunction = frame.OPEN;
            frame.openCloseButton.setText("Open");
            serial.closePort();
            frame.showMessageDialog("             Port closed");
          }
        }

        if(serial.dataBuffer != "") {
          frame.temperatureValueLabel.setText(serial.dataBuffer);
          serial.dataBuffer = "";           
        }

        if(frame.slidersFlag == true) {
          frame.slidersFlag = false;
          serial.sendColorData(frame.redColorSlider.getValue(), frame.greenColorSlider.getValue(), frame.blueColorSlider.getValue());
        }
      }
    };
        
    Timer timer = new Timer();
    timer.scheduleAtFixedRate(timerTask, 0, 200);
  }    
}