Прилад прийому та обробки метеорологічних даних (стр. 17 из 18)

continue;// якщо помилка – перериваємо обробку модуля}}

drowModules(modulesToDraw);

if (errStr.length() > 0) JOptionPane.showMessageDialog(this, errStr);}

private void drowOneModule(Module module)// прорисовка даних про один модуль

{System.err.println(""+module.getWeatherData().getRealTemperature());

System.err.println(""+module.getWeatherData().getRealPresure());

Object[][] objectData = new Object [][]{

{module.getModuleNumber(),

module.getWeatherData().getRealTemperature(),

module.getWeatherData().getRealPresure(),

module.getWeatherData().getRealWindDirection(),

module.getWeatherData().getRealWindPower()}};

tableModel = new DefaultTableModel(objectData, tableColumnNames);

table.setModel(tableModel);}

//рисуємо відразудекілька модулів

private void drowModules(ArrayList modules)

{Object [][] objectData = new Object[modules.size()][5];

for (int i = 0; i < modules.size(); i++)

{Module m = (Module)modules.get(i);

objectData[i][0] = m.getModuleNumber();

objectData[i][1] = m.getWeatherData().getRealTemperature();

objectData[i][2] = m.getWeatherData().getRealPresure();

objectData[i][3] = m.getWeatherData().getRealWindDirection();

objectData[i][4] = m.getWeatherData().getRealWindPower();}

tableModel = new DefaultTableModel(objectData, tableColumnNames);

table.setModel(tableModel);}

//читаємо з файлу список активних модулів

private void readModulesFromFile(){

listModel.clear();

ResourceBundle bundle = null;

bundle = ResourceBundle.getBundle("m"/*, new Locale("ru", "RU")*/);

Enumeration modules = bundle.getKeys();

while (modules.hasMoreElements()) {

Integer moduleNumber = new Integer(modules.nextElement()+"");

String moduleDescription = bundle.getString(moduleNumber + "");

Module module = new Module(moduleNumber, moduleDescription);

activeModules.add(module);

listModel.addElement(module);}

list.setModel(listModel);}

public ParallelPort getParalellPort(){return ourParallelPort;}

public static void main(String[] args)

{JFrame frame = getMainFrame();

frame.show();}}

Клас ui.UserSettingsDialog

package dip.ui;

//імпорт необхідних пакетів

import java.awt.*;

import javax.swing.*;

//поля класу

private JButton okButton = new JButton();

private JButton cancelButton = new JButton();

private JTextField waitForResponseFld = new JTextField();

private JCheckBox isTestModuleCheck = new JCheckBox();

public class UserSettingsDialog extends JDialog {

public UserSettingsDialog(Frame owner) {

super(owner, "Настройки користувача", true);

try

{jbInit();

pack();}

catch(Exception ex) {

ex.printStackTrace();}}

//відображення графічного стану діалогу

private void jbInit() throws Exception {

this.getContentPane().setLayout(new FlowLayuout());

this.getContentPane().add(new JLabel("Тестовый режим"));

this.getContentPane().add(isTestModuleCheck);

this.getContentPane().add(new JLabel("Время ожидания милисекунд"));

this.getContentPane().add(waitForResponseFld);

this.getContentPane().add(cancelButton);

this.getContentPane().add(okButton);

//додаємо необхідні прослуховувачі

okButton.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

Helper.WaitForResponceInMilis = new Integer(waitForResponseFld.getText());//затримка для чекання

Helper.TEST_MODE = isTestModuleCheck.isSelected();//вибір режиму роботи з програмою}});

cancelButton.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(ActionEvent e) {

this.setVisible();}});}}

Клас util.BadEvent

package dip.util;

import java.awt.Component;

import javax.swing.JOptionPane;

public class BadEvent//власні оброблювачі помилок

{public static void throwCriticalEvent(Exception ex, Component sourse, String message)

{ex.printStackTrace();

JOptionPane.showMessageDialog(sourse, message);

System.exit(0);//у разі критичної помилки – виходимо з програми}

public static void throwNonCriticalEvent(Exception ex, Component sourse, String message)

{ex.printStackTrace();

JOptionPane.showMessageDialog(sourse, message);//у разі помилки видаємо повідомлення}}

Клас util.Helper

package dip.util;

import java.util.ResourceBundle;

import java.util.StringTokenizer;

public class Helper {

public static int WaitForResponceInMilis = 10;//очикування відповіді

public static int syncroTime = 10000;//тривалість синхроімпульсу

public static int dataTime = 40000;//тривалість інформаційного рівня сигналу

public static boolean TEST_MODE = false;//наявність тестового режиму

public static byte[] integerToBytes(int number)

{byte [] bytes = new byte [16];

String str01 = Integer.toBinaryString(number);

int length = 16-str01.length();

for (int i = 0; i < length; i++) {

str01="0"+str01;//дописуємо (якщо необхідно) послідовність нулів}

for (int i = 0; i < str01.length(); i++)

{bytes[i] = Byte.parseByte(str01.substring(i, i+1));

System.err.print(""+bytes[i]);}

System.err.println("");

return bytes;}

public static byte [] testStringIntoBytes(int moduleNumber)

{ResourceBundle bundle = ResourceBundle.getBundle("TestValues");

byte [] bytes = new byte[Receiver.PACKAGE_SIZE];

String valueDigits = "";

try

{valueDigits = bundle.getString(moduleNumber + "");}

catch (Exception ex) {return null;}

StringTokenizer token = new StringTokenizer(valueDigits);

int k = 0;

int tokenCount = 0;

while (token.hasMoreTokens()){

Integer value = new Integer(token.nextToken());//розбір тестової строки

byte [] b = integerToBytes(value.intValue());

for (int i = 0; i < b.length ; i++)

{// System.err.println("i+k="+(i+k)+" i="+i+" k="+k+" moduleNumber="+moduleNumber);

bytes[i+k] = b[i+1];//для подачі відповідних сигналів на DR0, DR1}

k = k+16;

tokenCount++;

if (tokenCount > 7) break;//перевірка, якщо проаналізували тестову строку}

// for (int i = 0; i < bytes.length; i++) {

// System.err.print(bytes[i]);

//}

return bytes;}

public static void main(String[] args) {

// integerToBytes(255);

testStringIntoBytes((byte)2);}}

Клас util.Receiver

package dip.util;

import java.io.*;

import javax.swing.JFrame;

import javax.comm.ParallelPort;

public class Receiver extends Thread{//даний клас є потоком

public static final int PACKAGE_SIZE = 1;//размер читаемого пакета

private InputStream in = null;

private ParallelPort parallelPort = null;

private JFrame owner = null;

private static Receiver receiver = null;

public byte [] buffer = new byte [PACKAGE_SIZE];//вхідний буфер даних

private int startCounter = 0;

public int counter = 0;

private Receiver()

{}

public static Receiver getInstanse()//тримаємо лише один активний екземпляр класу

{if (receiver.isAlive()) return receiver;

receiver = new Receiver();

return receiver;}

private byte readByte()//читання байту (біту) з паралельного порту

{byte b = 0;

if (parallelPort.isPaperOut())//якщо є синхроімпульс

{b = (parallelPort.isBusy()) ? 1 : 0;//читаємо

parallelPort.setPaperOut(true);//скидуємо сигнал синхроімпульсу}

return b;}

public void run()

{while (true) {

byte currentByte = 0;

currentByte = readByte();

if (currentByte == 1) startCounter++;

else startCounter = 0;

if (startCounter == 7) {//якщо пройшла стартова послідовність

buffer[counter++] = b;

if (counter == PACKAGE_SIZE) {//якщо буфер повний

this.interrupt();}

try

{Thread.sleep(0, 100);//затримка у 0,1 мкс для звільнення процесорного часу}

catch (InterruptedException e) {}}}}

public void setIn(InputStream in) {

this.in = in;}

public JFrame getOwner() {

return owner;}

public void setOwner(JFrame owner) {

this.owner = owner;}

public void setParalellPort(ParallelPort parallelPort) {

this.parallelPort = parallelPort;}

public byte [] getBuffer() {return buffer;}}

Клас util.Transmitter

package dip.util;

import javax.comm.ParallelPortEventListener;

import javax.comm.CommPortOwnershipListener;

import javax.comm.ParallelPortEvent;

import java.io.OutputStream;

import javax.comm.ParallelPort;

import java.io.*;

import javax.swing.JOptionPane;

import javax.swing.JFrame;

public class Transmitter {

private static Transmitter transmitter = null;

private JFrame owner = null;

private OutputStream out = null;

private ParallelPort parallelPort = null;

public static final int PACKAGE_SIZE = 8;//довжина пакету, що посилається

public static final int SYNCROCOUNT = 8;//кількість підзаряжувальних синхроімпульсів

public static Transmitter getInstance()//маємо лише один екземпляр класу

{if (transmitter != null) return transmitter;

transmitter = new Transmitter();

return transmitter;}

private Transmitter()

{}

public OutputStream getOut() {

return out;}

public void setOut(OutputStream out) {

this.out = out;}

public void sendBytes (byte [] byte01)

{doStartQuery();//спочатку передаємо стартову послідовність

for (int i = 0; i < byte01.length ; i++)

sendByte(byte01[i]);}

private void sendByte(byte b)

{try

{this.getOut().write(b);//запис до відповідного регістру

try { Thread.sleep(0, Helper.dataTime); } catch (InterruptedException ex) { }//встановлюємо затримку

sendSyncro();//посилаємо синхроімпульс}

catch (IOException ex)

{ex.printStackTrace();

System.err.println("Не могу записать в параллельный порт!");}}

private void sendSyncro()

{this.parallelPort.setInputSelect(true);//встановлюємо сигнал

try { Thread.sleep(0, Helper.syncroTime); } catch (InterruptedException ex) { }//затримка

this.parallelPort.setInputSelect(false);//скидаємо сигнал}

private void doStartQuery()

{for (int i = 0; i < 8; i++)//спочатку синхроімпульси

sendByte((byte)0);

for (int i = 0; i < 8; i++)//потім – послідовність «одиниць»

sendByte((byte)1);}

private void writeTestQuery(byte [] testBytes)

{if (testBytes.length != Receiver.PACKAGE_SIZE + 8)

{ System.err.println("Неспівпадння довжини пакету");

return;}

for (int i = 0; i < testBytes.length; i++)

{parallelPort.setPaperOut(testBytes[i]==2);//пишемо «1» якщо 2, інакше – «0»

try { Thread.sleep(0, Helper.dataTime); } catch (InterruptedException ex) { }

parallelPort.setPaperOut(false);

//задання синхронмульсу

parallelPort.setPaperOut(true);

try { Thread.sleep(0, Helper.syncroTime); } catch (InterruptedException ex) { }

parallelPort.setPaperOut(false);}}

public JFrame getOwner() {

return owner;}

public void setOwner(JFrame owner) {

this.owner = owner;}

public void setParallelPort(ParallelPort parallelPort) {

this.parallelPort = parallelPort;}}

Клас obj.WeatherData

package dip.obj;

import dip.util.Helper;

public class WeatherData

{private int temperature = 0;

private int presure = 0;

private int wind1 = 0;

private int wind2 = 0;

private int wind3 = 0;

Double realTemperature ;//температура

Integer realPresure ;//тиск

Double realWindDirection ;//напрямок вітру

Double realWindPower ;//сила вітру

int src = 0;

public int moduleNumber = 0;

byte [] bTemperature = new byte[16];

byte [] bPresure = new byte[16];

byte [] bWind1 = new byte[16];

byte [] bWind2 = new byte[16];

byte [] bWind3 = new byte[16];

byte [] bSrc = new byte[16];

byte [] bModuleNumber = new byte[8];

byte [] receivedBytes ;

public WeatherData(byte [] receivedBytes)

{this.receivedBytes = receivedBytes;

initValues();}

private void initValues()//аналіз прийнятої послідовності

{for (int i = 0; i < receivedBytes.length; i++)

{receivedBytes[i]+=Receiver.PACKAGE_SIZE;

if (i>=0 && i<=7) bModuleNumber[i] = receivedBytes[i];

if (i>=8 && i<=23) bTemperature[i-8] = receivedBytes[i];

if (i>=24 && i<=39) bPresure[i-24] = receivedBytes[i];

if (i>=40 && i<=55) bWind1[i-56] = receivedBytes[i];

if (i>=56 && i<=71) bWind2[i-72] = receivedBytes[i];

if (i>=72 && i<=87) bWind3[i-72] = receivedBytes[i];

if (i>=88 && i<=103) bSrc[i-104] = receivedBytes[i];}

moduleNumber = Integer.parseInt(new String(bModuleNumber), 2);

temperature = Integer.parseInt(new String(bTemperature), 2);

presure = Integer.parseInt(new String(bPresure), 2);

wind1= Integer.parseInt(new String(bWind1), 2);

wind2 = Integer.parseInt(new String(bWind2), 2);

wind3 = Integer.parseInt(new String(bWind3), 2);

src = Integer.parseInt(new String(bSrc), 2);

reliveValues();}

public void reliveValues()

{if (checkSrc())

{if (temperature > 61440)//1111 0000 0000 0000 якщо мінусова температура

{temperature = temperature << 4;

temperature = 0 - temperature;}

realTemperature = new Double(temperature/16);

realPresure = new Integer(presure);

double w1, w2,w3, s1,s2;

w1 = windFunction(wind1);

w2 = windFunction(wind2);

w3 = windFunction(wind3);//обчислення показників за формулою

s1 = w1*Math.cos(Math.pi*0)+w2*Math.cos(Math.pi*(-2/3))+w2*Math.cos(Math.pi*(2/3));//a1+a2+a3

s2 = w1*Math.sin(Math.pi*0)+w2*Math.sin(Math.pi*(-2/3))+w2*Math.sin(Math.pi*(2/3));//b1+b2+b3

realWindPower = new Double(Math.sqrt(s1*s1+s2*s2));//знаходимо силу вітру

realWindDirection = new Double(Math.arctg(s2/s1));// та напрямок}}

private double windFunction(double chastota)

{if (chastota > 2) /обчислення показників за формулою

return (double)(1.614878*Math.sqrt(198.304-49.5759*f*f));

else return (double)(1.614878*Math.sqrt(49.5759*f*f-198.304));}

public boolean checkSrc()

{return (src == (temperature ^ presure ^ windPower ^ windDirection));//перевірка контрольної суми}

public Integer getRealPresure() {

return realPresure;}

public Double getRealTemperature() {

return realTemperature;}

public Integer getRealWindDirection() {

return realWindDirection;}

public Double getRealWindPower() {

return realWindPower;}

public void setRealPresure(Integer realPresure) {

this.realPresure = realPresure;}

public void setRealTemperature(Double realTemperature) {

this.realTemperature = realTemperature;}

public void setRealWindDirection(Integer realWindDirection) {

this.realWindDirection = realWindDirection;}

public void setRealWindPower(Double realWindPower) {

this.realWindPower = realWindPower;}

public static void main(String[] args) {

System.err.println(55^144^85^10);

System.err.println(48^93^15^78);

System.err.println(255^13^2^7);

System.err.println(77^66^34^32);

System.err.println(217^207^105^35);

System.err.println(56^199^201^124);

System.err.println(43^14^1^91);