Обеспечение всемирной трансляции спортивных шахматных соревнований с применением разработанного в ходе проекта законченного программного продукта (стр. 24 из 27)
if (start == d.length) return;
if (state == 0) { // Find a known messageid.
while (start<d.length) {
if (is_busmessage(d[start])) {
messagetype = d[start];
state = 1;
_receive(d,start+1);
return;
}
System.err.println("Did not understand 1 byte of incoming data.");
start = start + 1;
}
return;
}
if (state == 1) {
if ((d[start] & 0x80) > 0) {
System.err.println("Did not understand 2 bytes of incoming data.");
state = 0;
_receive(d, start);
return;
}
messagelen_msb = d[start];
state = 2;
start = start + 1;
}
if (start == d.length) return;
if (state == 2) {
if ((d[start] & 0x80) > 0) {System.err.println("Did not understand 3 bytes of incoming data.");
state = 0;
_receive(d, start);
return;
}
messagelen_lsb = d[start];
state = 3;
start = start + 1;
int newlen = ((int)messagelen_msb * 0x80) + (int)messagelen_lsb;
if (newlen <5) {
System.out.println("Too small message length: " + Integer.toString(newlen));
state = 0;
_receive(d, start);
return;
}
data = new int[newlen];
data[0] = messagetype;
data[1] = messagelen_msb;
data[2] = messagelen_lsb;
useddata = 3;
}
if (start == d.length) return;
if (state == 3) {
while (start<d.length && useddata<data.length) {
data[useddata]=d[start];
start = start + 1;
useddata = useddata + 1;
}
if (useddata == data.length) {
interpreter.interpret(data);
start = start + 1;
data = null;
state = 0;}
}
_receive(d, start);
}
}
rdgtSender.java
---
class rdgtSender extends rdgtProtocol {
rdgtSerialport com;
public rdgtSender(rdgtSerialport _com) {
com = _com;
}
void send(int message, int address) {
String tmp = "Address:"+Integer.toString(address);
System.out.println();
if (message==DGT_TO_BUSMODE) System.out.println("Sending message: SWITCH TO BUSMODE "+tmp);
else if (message==DGT_BUS_SEND_BRD) System.out.println("Sending message: SEND BOARD "+tmp);
else if (message==DGT_BUS_SEND_CHANGES) System.out.println("Sending message: SEND CHANGES "+tmp);
else if (message==DGT_BUS_REPEAT_CHANGES) System.out.println("Sending message: REPEAT CHANGES "+tmp);
else if (message==DGT_BUS_PING) System.out.println("Sending message: PING "+tmp);
else if (message==DGT_BUS_IGNORE_NEXT_BUS_PING) System.out.println("Sending message: IGNORE NEXT PING "+tmp);
else System.out.println("Sending message: (some other message)");
byte x[] = new byte[4];
x[0] = (byte)message;
x[1] = (byte)((address>>7) & 0x7F);
x[2] = (byte)(address & 0x7F);
x[3] = (byte)(((int)x[0]+(int)x[1]+(int)x[2]) & 0x7F);
com.write(x);
}
}
rdgtSerialport.java
---
class rdgtSerialport implements SerialPortEventListener {
static CommPortIdentifier portid;
InputStream inStream;
OutputStream outStream;
SerialPort serialPort;
rdgtReceiver receiver;
public rdgtSerialport(rdgtReceiver r) {
receiver = r;
}
public boolean open(String portname) {
CommPortIdentifier id = null;
Enumeration portList;
portList = CommPortIdentifier.getPortIdentifiers();
System.out.println(portList.toString());
while (portList.hasMoreElements()) {
System.out.println("2");
id = (CommPortIdentifier) portList.nextElement();
if (id.getPortType() == CommPortIdentifier.PORT_SERIAL) {
System.out.println("Ports: "+id.getName());
if (id.getName().equals(portname)) break; // found
}
id = null;
}
if (id == null) return false; // not found
try {
serialPort = (SerialPort) id.open("ttchess", 2000);
inStream = serialPort.getInputStream();
outStream = serialPort.getOutputStream();
serialPort.addEventListener(this);
serialPort.notifyOnDataAvailable(true);
serialPort.setSerialPortParams(9600, SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,SerialPort.PARITY_NONE);
serialPort.setDTR(false);
serialPort.setRTS(false);
} catch (Exception e) { return false; }
return true;
}
public boolean write(byte[] data) {
char c[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
StringBuffer x = new StringBuffer(" Sending: ");
for (int i=0; i<data.length; i=i+1) {
int d = data[i];
if (d<0) d=256+d;
x.append(c[d>>4]).append(c[d & 0x0F]).append(" ");
}
if (rdgtChess.debug) System.out.println(x.toString());
try {
outStream.write(data);
} catch (IOException e) { return false; }
return true;
}
public void serialEvent(SerialPortEvent event) {
switch(event.getEventType()) {
case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
break;
case SerialPortEvent.DATA_AVAILABLE:
byte[] readBuffer = new byte[200];
try {
while (inStream.available() > 0) {
int numBytes = inStream.read(readBuffer);
if (numBytes>0) {
int[] buf = new int[numBytes];
for (int i=0; i<numBytes; i=i+1) {
int tmp = readBuffer[i];
if (tmp<0) tmp=256+tmp;
buf[i]=tmp;
}
receiver.receive(buf);
}
}
} catch (IOException e) {}
break;
}
}
}
rdgtSnapshot.java
---
class rdgtSnapshot extends rdgtProtocol {
int[] pieces = new int[64];
Date time;
rdgtChessboard board;
boolean clkRunning, clkBatteryLow, clkFrontViewLeftSideHigh, clkBlackTurn, clkWhiteTurn;
int clkSecWhite, clkSecBlack;
public rdgtSnapshot(rdgtChessboard _board) {
time = new Date();
board = _board;
set_emptyboard();
}
public rdgtSnapshot(rdgtSnapshot x) {
for (int i=0; i<64; i=i+1) pieces[i] = x.pieces[i];
time = x.time;
board = x.board;
clkRunning = x.clkRunning;
clkBatteryLow = x.clkBatteryLow;
clkFrontViewLeftSideHigh = x.clkFrontViewLeftSideHigh;
clkBlackTurn = x.clkBlackTurn;
clkWhiteTurn = x.clkWhiteTurn;
clkSecWhite = x.clkSecWhite;
clkSecBlack = x.clkSecBlack;
}
rdgtSnapshot copy() {
return new rdgtSnapshot(this);
}
void set_clockdata(boolean running, boolean batteryLow, boolean frontViewLeftSideHigh,
boolean blackTurn, boolean whiteTurn, int secW, int secB) {
clkRunning = running;
clkBatteryLow = batteryLow;
clkFrontViewLeftSideHigh = frontViewLeftSideHigh;
clkBlackTurn = blackTurn;
clkWhiteTurn = whiteTurn;
clkSecWhite = secW;
clkSecBlack = secB;
}
public boolean sameas(rdgtSnapshot x) {
for (int i=0; i<64; i=i+1) if (pieces[i] != x.pieces[i]) return false;
return true;
}
Date get_time() { return time; }
void set_emptyboard() {
time = new Date();
for (int i=0; i<64; i=i+1) pieces[i]=EMPTY;
}
void set_boarddump(int[] all64, int startpos) {
time = new Date();
for (int i=0; i<64; i=i+1) {
int p = all64[i+startpos];
if (is_piece(p)==false) {
System.out.println("Confused: Boarddump contained an unknown piece");
pieces[i]=EMPTY;
} else {
pieces[i]=p;
}
}
}
void set_fieldupdate(int piece, int pos) {
time = new Date();
if (pos <0 || pos > 63) {
System.out.println("Confused: Fieldupdate for pos outside 0..63");
return;
}
if (is_piece(piece)==false) {
System.out.println("Confused: Fieldupdate with an unknown piece");
return;
}
pieces[pos]=piece;
}
String seconds2hms(int s) {
return Integer.toString(s/36000)+Integer.toString((s%36000)/3600)+":"+
Integer.toString((s%3600)/600)+Integer.toString((s%360)/60)+":"+
Integer.toString((s%60)/10)+Integer.toString(s%10);
}
String debugprint_clock() {
StringBuffer s = new StringBuffer(50);
s.append("Clock: White "); s.append(seconds2hms(clkSecWhite));
s.append(" Black "); s.append(seconds2hms(clkSecBlack));
System.out.println(s);
return s.toString();
}
String getTimeWhite(){
return seconds2hms(clkSecWhite);
}
String getTimeBlack(){
return seconds2hms(clkSecBlack);
}
boolean isWhiteTurn(){
return clkFrontViewLeftSideHigh;
}
String debugprint() {
debugprint_clock();
StringBuffer s = new StringBuffer(300);
for (int i=0; i<8; i=i+1) {
for (int j=0; j<8; j=j+1) {
int p = pieces[(i*8)+j];
if (p==EMPTY ) s.append(".");
if (p==WPAWN ) s.append("P");
if (p==WROOK ) s.append("R");
if (p==WKNIGHT) s.append("N");
if (p==WBISHOP) s.append("B");
if (p==WKING ) s.append("K");
if (p==WQUEEN ) s.append("Q");
if (p==BPAWN ) s.append("p");
if (p==BROOK ) s.append("r");
if (p==BKNIGHT) s.append("n");
if (p==BBISHOP) s.append("b");
if (p==BKING ) s.append("k");
if (p==BQUEEN ) s.append("q");
}
s.append("\n");
}
System.out.println(s);
return s.toString();
}
}
Приложение Д
Снимки экрана
Д.1 Снимок экрана главной страницы сервера трансляции шахматных партий rDGT
Д.2 Снимок экрана страницы авторизации пользователя
Д.3 Снимок экрана страницы просмотра текущих online трансляций
Д.4 Снимок экрана страницы просмотра шахматной партии
Приложение Е
Протокол DGT
#ifndef dgtbrd13
#define dgtbrd13
/*
Protocol description for DGT chess board.
Copyright 1998 DGT Projects B.V
Version: 1.03 Single computer and bus support in one .h file
*********************************************************
This protocol is protected under trade mark registration and copyrights.
It may not be used commercially without written permission
of DGT Projects B.V. It is illegal to transfer any registered trade mark
identifications by means of this protocol between any chessboard or other
application and any computer.
*********************************************************
Main functionality of the DGT Electronic Chess Board
----------------------------------------------------
The DGT board is basically a sensor which senses the presense of the special
chess set pieces on the squares of the board. The situation on the board is
measured and can be communicated with an average maximum time delay of
200 mS.
Besides this detection function, the board communicates with an optional
DGT TopMatch Chess Clock, to give the data of the clock available to the
general interface.
Finally the board is equipped with an internal storage of the measured
piece positions.
The board supports two methods of communication: for single-board situations
a protocol for communication between one board and one computer is available.
For situations with many boards a network communications protocol is
available, where many boards can be connected in a bus structure. A separate
communication protocol is available for this bus structure.
The communication protocol for single board connections is described
in the following paragraph "Single board communication protocol". This
paragraph describes much more than only the communication protocol. All
developers should read this paragraph, even if they would only use bus
communication.
The special bus communication protocol is derived from the single board
communication and functionality, where the main added feature is the
possibility to address a specific board on a shared communication bus.
The commands and data contens are described in the paragraph "Bus
Communication Protocol", Note however that the contens can not be understood
without reading the single board communication paragraph.
Paragraph: Single board communication protocol
----------------------------------------------
The main function of the board is to transfer piece position information.
For this, three modes are available:
1. IDLE mode. This cancelles any of the two UPDATE modes. No automatic
transfer of moves.
2. UPDATE_BOARD mode. On the moment that the board detects a removal, change
or placing of a piece, it outputs a DGT_SEND_UPDATE message
3. UPDATE mode. As UPDATE_BOARD mode, where additional the clock data are send
regularly (at least every second)
The board accepts command codes from the computer RS232. The commands are
1-byte codes, sometimes followed by data (see code definition)
The board can send data to the computer. Data always carries a message header.
The message header contains a message code and the total message size in bytes.
The start of the incoming message can be recognised by the MSB of the message
identifier set to 1 (see definition).
Board to computer communication interfaces:
RS232 for communication with computer, receiving commands, sending data
- 9600 Baud, 1 stopbit, 1 startbit, no parity
- No use of handshaking, neither software nor hardware
Connection between Digital Game Timer TopMatch Clock and the board:
Based on NEC SBI protocol. Adaption of the definition given in
the DGT TopMatch documentation.
Connector assignments for DGT Electronic Board: See User
and Programmers Manual
Related to the before mentioned modes, and to piece position information
transfer, the following commands to the board are available:
1. DGT_SEND_RESET
puts the DGT Board in IDLE mode
2. DGT_SEND_CLK
on which the DGT board responds with a DGT_MSG_BWTIME message containing clock
information
3. DGT_SEND_BRD
on which the DGT Board responds with a DGT_MSG_BOARD_DUMP message containing
the actual piece exising of all fields
4. DGT_SEND_UPDATE puts the DGT Board in the UPDATE mode, FRITZ5 compatible
5. DGT_SEND_UPDATE_BRD puts the DGT Board in the UPDATE_BOARD mode
6. DGT_SEND_UPDATE_NICE puts the board in UPDATE mode, however transferring only clocktimes when any time info changed.
The DGT_SEND_CLK command and the DGT_SEND_BOARD command do not affect the current board
mode: i.e. when in UPDATE mode, it continues sending DGT_SEND_UPDATE messages.
Board Identification:
Each DGT Electronic Board carries a unique serial number,
a EEPROM configuration version number and a embedded program version number.
These data are unalterable by the users.
Current identification is:
"DGT Projects - This DGT board is produced by DGT Projects.\n
DGT Projects is a registered trade mark.\n
220798 ISP/bus/8KP/8KE/P6/Fritz5 Vs 1.00. Serial nr. 00137 1.0"
The board can be loaded by the user with a non-volatile one-byte bus number,
for future use with multiple board configurations.
On-board EEPROM:
The board carries a 8 kB cyclic non-volatile memory, in which all position
changes and clock information is stored during all power-up time. This
file can be read and processed.
Start of Definitions:
---------------------*/
/* COMMAND CODES FROM PC TO BOARD: */
/* resulting in returning message(s): */
#define DGT_SEND_CLK 0x41
/* results in a DGT_MSG_BWTIME message */
#define DGT_SEND_BRD 0x42
/* results in a DGT_MSG_BOARD_DUMP message */
#define DGT_SEND_UPDATE 0x43
/* results in DGT_MSG_FIELD_UPDATE messages and DGT_MSG_BWTIME messages
as long as the board is in UPDATE mode */
#define DGT_SEND_UPDATE_BRD 0x44