GB KISS LINK Technical Documentation 0.1
March 29, 2025
Shonumi aka D.S. Baxter 

***************************************************
1. Introduction
***************************************************

The GB KISS LINK is an infrared modem that connects to PCs in order to send/receive data from Game Boys. It was made by Hudson and released on March 6, 1998. The unit sold through mail order to the ASCII Corporation and was compatible with select titles that featured HuC-1 and HuC-3 cartridge mappers. The infrared connectivity allowed data to flow freely between the user's PC and the Game Boys. It was most prominently used to transfer GBF files and Nectaris maps, some of which could be downloaded from Hudson's website.


***************************************************
2. General Hardware Information
***************************************************

- Unit came as a plain PCB protected only by a wrap-around plastic cover
- Powered by a single 9V battery
- Featured 2 infrared diodes for sending and receiving signals
- Connected to PC via D-SUB25 serial cable
- Required PC special Windows 95 software and drivers to use
- Officially uses the model number HC-749


***************************************************
3. Compatible Games
***************************************************

Only a handful of games used HuC-1 and HuC-3 mappers. Within this group, an even smaller selection took advantage of the GB KISS LINK for downloadable content provided online by Hudson. The list below notes these titles along with what kinds of features were enabled by the GB KISS LINK.


- Nectaris
* Mapper: HuC-1
* Features: Downloading custom maps


- Pocket Family GB
* Mapper: HuC-3
* Features: Downloading custom alarm songs and a family photo event


Other games are more broadly compatible with the GB KISS menu, a standardized menu that allows content to be shared between other Game Boys or via the GB KISS LINK. These, however, were not known to specifically have any downloadable content from Hudson.


- Daikaiju Monogatori: The Miracle of the Zone
- GBKiss Mini Games
- Pocket Bomberman
- Robot Poncots (Sun, Star, Moon, and Comic BomBom Versions)
- Super B-Daman Fighting Phoenix


***************************************************
4. GBF Infrared Protocol Overview
***************************************************

The GB KISS LINK uses a specific protocol to communicate with GB KISS compatible software to transfer GBF files. This protocol appears to be the same regardless if the sender or receiver is a Game Boy or the GB KISS LINK. Below is a high-level description of how the protocol works:

----------------------------------------------------------------------------------------------------------------------
Sender							| Receiver
----------------------------------------------------------------------------------------------------------------------
1)  Read Receiver ID String				| 1)  Return ID String
2)  Send Transfer Start Flag				| 2)  Get Transfer Start Flag
3)  Start Session					| 3)  Wait
4)  Send Title and Icon data				| 4)  Get Title and Icon Data, Return File Search Input + Echo
5)  Search File						| 5)  Return File Metadata and Echo of Title and Icon data
6)  Unknown Read					| 6)  Return Unknown Data
7)  Prep File Data Transfer				| 7)  Wait
8)  Send History Data					| 8)  Get History Data, Return ACK Data
9)  Send File Data					| 9)  Get File Data, Return ACK Data
10) End File Data Transfer				| 10) Return File Metadata and ACK Data
11) Send Cartridge Code					| 11) Get Cartridge Code, Return ACK Data
12) Send Transfer End Flag				| 12) Get Transfer End Flag
13) End Session						| 13) End Session
----------------------------------------------------------------------------------------------------------------------

The sender dictates the flow of communications by sending a pair of "magic bytes" (0x48 and 0x75) along with a 10-byte command packet in the following format:

---------------------------------------------------------
Byte	| Description
---------------------------------------------------------
0	| Transfer Status
1	| Command Byte
2	| Local Address Lo
3	| Local Address Hi
4	| Remote Address Lo
5	| Remote Address Hi
6	| Data Operation Length
7	| Parameter
---------------------------------------------------------

Transfer Status is a bit-field that alerts the receiver if any errors have occured on the sender's side. Most GB KISS LINK software, seem to ignore this as long as the value is non-zero. When transferring a GBF file, the sender normally uses a constant value of 0x30 for the Transfer Status.

The Command Byte tells the receiver what operation is being performed during the transfer. Its value indicates whether the receiver should wait for the next command or start returning data. There are a just a few commands used for GBF file transfers:

---------------------------------------------------------
Command	| Description
---------------------------------------------------------
0x00	| Start/Stop Session
0x02	| Send Title and Icon Data
0x03	| File Search
0x04	| Start/Stop File Data Transer
0x08	| Read Remote RAM
0x0A	| Send File Data
0x0B	| Write Remote RAM
---------------------------------------------------------

Local/Remote Addresses are often analogous to Source/Destination Addresses, depending on the command. This allows the sender to specify where in RAM to pull data and where to push it when the receiver gets it.

Data Operation Length specifies how many bytes a given command should read or write, if applicable. Some commands may repurpose this byte for other uses (such File Search).

The final byte is a miscellaneous parameter that changes context based on the command. For example, often times it is used to specify which slot within the GB KISS Menu the GBF file will be written to.

At the very end of a command packet, an 8-bit checksum is sent out. This is the sum of all previous 8 bytes bitwise complemented and incremented by 1:

SUM = SUM OF ALL BYTES
SUM = ~SUM
SUM = SUM + 1

For any command that sends data, those bytes come immediately after the command packet checksum. Additionally, the data is requires its own checksum at the end. Altogether, a complete command from the sender will look like this:

---------------------------------------------------------
1) Command Packet
2) Command Checksum
3) Data Bytes
4) Data Checksum
---------------------------------------------------------

Between each command from the sender and response from the receiver, a brief handshake is exchanged between both sides. The values used for these handshakes changes depending on which side is currently sending data. The handshake is as follows:

---------------------------------------------------------
Sending Data		| Receiving Data
---------------------------------------------------------
0xAA			| 0x55
0xC3			| 0x3C
---------------------------------------------------------

For example, when using the Read Remote RAM command, the sender initiates the handshake with the value 0xAA and waits for a 0x55 response. The sender then issues the byte 0xC3 and waits for a 0x3C response. When the receiver returns RAM data for the command, the roles are reversed. In this case, the sender must wait for the 0xAA and 0xC3 values and respond accordingly with 0x55 and 0x3C.


***************************************************
5. GBF Infrared Protocol Low Level
***************************************************

Individual bytes are transferred MSB-first. In an ideal environment, pulses representing a "1" bit have an ON-OFF transition of ~720 CPU cycles. Pulses representing a "0" bit have an ON-OFF transition of ~460 cycles. These numbers likely do not reflect real-world infrared timings, however, they do illustrate what the software itself considers acceptable. The ON period should be around ~200 cycles at minimum. Certain portions of the infrared protocol have unusual timings, chiefly the handshakes in between commands, and so-called "pings" that happen in between command and data bytes.

Handshakes start with a dummy pulse typically lasting around ~560 cycles. Afterwards, each bit is transferred. Following the last bit is a final pulse about ~1220 cycles long, which acts as a sort of stop signal:

---------------------------------------------------------
Handshake Pulses
---------------------------------------------------------
560		| Dummy Pulse
xxx		| Bits 7 - 0
1220		| Stop Pulse
---------------------------------------------------------

When transitioning from the handshake to sending/receiving a command, the sender initiates another Dummy Pulse. The ON phase of this pulse should be rather long (~400 cycles seems safe). Before this pulse completes, the receiver will trigger a very brief "ping" pulse. This lasts about ~100 cycles on average. This ping is done for the magic bytes as well as every byte of the command packet. The final ping is used to send the Command Checksum. The ping pulse may be a bit longer when the receiver needs some additional time to process data. This is commonly observed when verifying checksums. In any case, the sender should still issue a Dummy Pulse and wait for the ping to finish.


***************************************************
6. GBF Infrared Protocol In-Depth
***************************************************

This section will go through the entire protocol to transfer a GBF file step-by-step, outlining all of the data used by both the sender and receiver. Parts with "..." represent bytes with variable values. To begin, the sender constantly sends out the first byte of a handshake (0xAA) and briefly waits for a response. If there is no response, the process keeps looping until it the receiver is ready of the user quits the transfer manually. Once the receiver is detected, the handshake continues and afterwards the sender will request the receiver's ID with a Read Remote RAM command:

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status 
0x01		| 0x08			| Command Byte (Read Remote RAM)
0x02 - 0x03	| 0xCE00		| Local Address
0x04 - 0x05	| 0xCE00		| Remote Address
0x06		| 0x10			| Data Operation Length
0x07		| 0x00			| Parameter
0x08		| 0x1C			| Command Checksum
----------------------------------------------------------------------------------------------------------------------

The receiver the responds with an ASCII string: "GB KISS MENU ". This string must be an exact match, otherwise the sender will fail to initialize continue after a certain point. The receiver's respon looks like this:

----------------------------------------------------------------------------------------------------------------------
Receiver Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x00			|
0x01		| 0x02			|
0x02 - 0x0F	| "GB KISS MENU "	| Receiver ID String
0x10		| ...			| GB KISS Menu Slot Number
0x11		| ...			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

The receiver also sends the Slot Number where the GBF file will be written to the GB KISS Menu. After getting the receiver's ID, the sender will write a flag in the receiver's RAM indicating that a transfer is about to start:

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status 
0x01		| 0x0B			| Command Byte (Write Remote RAM)
0x02 - 0x03	| 0xCE00		| Local Address
0x04 - 0x05	| 0xCE00		| Remote Address
0x06		| 0x01			| Data Operation Length
0x07		| 0x00			| Parameter
0x08		| 0x28			| Command Checksum
0x09		| 0x01			| Data Byte (Tranfer Start Flag)
0x0A		| 0xFF			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

For all Write Remote RAM commands, the receiver simply responds with the Data Checksum it was sent. Next, the sender must begin the session as such:

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status 
0x01		| 0x00			| Command Byte (Start/Stop Session)
0x02 - 0x03	| 0xCE00		| Local Address
0x04 - 0x05	| 0xCE00		| Remote Address
0x06		| 0x01			| Data Operation Length
0x07		| 0x00			| Parameter
0x08		| 0x33			| Command Checksum
----------------------------------------------------------------------------------------------------------------------

There is a significant delay (about 1/4 of a second) after starting a session, probably so both sides can prepare for the coming transfers as well as changing the background tiles to indicate on-screen to the users that the transfer has begun. Next, Title and Icon data is transferred from the sender's GBF file:

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status 
0x01		| 0x02			| Command Byte (Send Title and Icon Data)
0x02 - 0x03	| 0xC700		| Local Address
0x04 - 0x05	| 0xC50C		| Remote Address
0x06		| ...			| Data Operation Length
0x07		| 0x00			| Parameter
0x08		| ...			| Command Checksum
0x09 - ...	| ...			| Title and Icon Data
...		| ...			| Title and Icon Data Checksum
----------------------------------------------------------------------------------------------------------------------

The length of Title and Icon Data is specified by the Byte 0x04 of the GBF file. The receiver responds with some data that can be used for the File Search function along with an echo of Title and Icon Data that was just sent:

----------------------------------------------------------------------------------------------------------------------
Receiver Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x90			| Transfer Status
0x01		| 0x00			|
0x02  - 0x03	| 0xC500		| Remote Address
0x04		| ...			| Title and Icon Length
0x05		| 0xC4			|
0x06  - 0x07	| 0x0000		|
0x08		| ...			| Checksum
0x09  - 0x12	| ...			| File Search Input
0x13		| ...			| Title and Icon Length
0x14  - 0x108	| ...			| Title and Icon Data
0x109		| ...			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

The total length of this transfer is *ALWAYS* 265 bytes. Since the Title and Icon data will not fill up this space, it seems random RAM bytes are transferred towards the very end before the Data Checksum. The format for File Search Input is currently not known. Note that in the case that a GBF file does not have its own icon, only the Title data will actually be transferred. The 11 bytes sent here are copied and used by the sender later on. Before that, the sender writes to the receiver's RAM for unknown reasons:

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status 
0x01		| 0x0B			| Command Byte (Write Remote RAM)
0x02 - 0x03	| 0xCE00		| Local Address
0x04 - 0x05	| 0xCE00		| Remote Address
0x06		| 0x01			| Data Operation Length
0x07		| ...			| Parameter (GB KISS Menu Slot Number)
0x08		| ...			| Command Checksum
0x09		| 0x05			| Data Byte (Tranfer Start Flag)
0x0A		| 0xFB			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

The parameter used above is the Slot Number for the GB KISS Menu. Again, the receiver responds with the Data Checksum that was just sent. The File Search command is called next:

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status
0x01		| 0x03			| Command Byte (File Search)
0x02  - 0x03	| 0xC700		| Local Address
0x04  - 0x05	| ...			| Raw File Size
0x06		| ...			| GB KISS Menu Slot Number
0x07		| ...			| GBF Flags
0x08		| ...			| Command Checksum
0x09  - 0x108	| ...			| File Search Input
0x109		| ...			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

The Raw File Size is the data within a GBF file *after* metadata has been stripped. That is to say, it's the data that comes after the File Size, Flags, Cartridge Code, Title+Icon Size, Creator Code, Title Data, Icon Data, and History Data. Depending on the GBF file, metadata can range in size from 6 to 256 bytes. The data following that is the "raw" data for a GBF file. Once again, the sender specifies the GB KISS Menu Slot Number. It also sets the GBF Flags, which is Byte 0x02 of the GBF file. File Search Input is an exact copy of the response data from the Send Title and Icon Data command, so this command is always 265 bytes total. The receiver sends the following data in response to the File Search command:

----------------------------------------------------------------------------------------------------------------------
Receiver Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x80			| Transfer Status
0x01		| 0x00			|
0x02  - 0x03	| 0xC500		| Local Address
0x04  - 0x05	| 0xC50C		| Remote Address
0x06		| 0x00			|
0x07		| ...			| ??? Used as a parameter for next Read Remote RAM command
0x08		| ...			| Checksum
0x09  - 0x0A	| ...			| ???
0x0B		| 0x00			|
0x0C  - 0x0D	| ...			| Metadata Size
0x0E  - 0x0F	| ...			| Metadata Size
0x10  - 0x11	| ...			| Total File Size
0x12		| ...			| GBF Flags
0x13		| 0xFF			|
0x14		| ...			| Title and Icon Size
0x15  - 0x108	| ...			| Title and Icon Data
0x109		| ...			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

After this, the sender requests an unknown read from the receiver. It uses whatever parameter was previously Byte 0x07 of the above File Search response:

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status
0x01		| 0x08			| Command Byte (Read Remote RAM)
0x02 - 0x03	| 0xCE00		| Local Address
0x04 - 0x05	| 0xDFFC		| Remote Address
0x06		| 0x02			| Data Operation Length
0x07		| ...			| Parameter (Byte 0x07 from previous response data)
0x08		| ...			| Command Checksum
----------------------------------------------------------------------------------------------------------------------

The response data appears to be constant no matter what kind of GBF file is being transferred:

----------------------------------------------------------------------------------------------------------------------
Receiver Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x05			|
0x01		| 0x02			|
0x02		| 0xFB			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

Next, the sender sends a command that appears to prep both sides to start uploading file data. Interestingly, History Data seems to be included as part of the file upload process despite being metadata:

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status
0x01		| 0x04			| Command Byte (Start/Stop File Data Transfer)
0x02 - 0x03	| 0xC500		| Local Address
0x04 - 0x05	| 0xFFD2		| Remote Address
0x06		| 0x2E			| Data Operation Length (no data sent, but this is the max length of History Data)
0x07		| 0x00			| Parameter
0x08		| 0x08			| Command Checksum
----------------------------------------------------------------------------------------------------------------------

The receiver then sends an ACK packet of data:

----------------------------------------------------------------------------------------------------------------------
Receiver Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x40			| Transfer Status
0x01		| 0x01			|
0x02 - 0x03	| 0xC500		| Local Address
0x04 - 0x05	| 0xFFD2		| Remote Address
0x06 - 0x07	| ...			| Metadata Size
0x08		| ...			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

Next, the sender transfers any History Data available. This command is always called even if the GBF file has no History Data. In that case, the Data Operation Length is simply zero.

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status
0x01		| 0x0A			| Command Byte (Send File Data)
0x02 - 0x03	| 0xC500		| Local Address
0x04 - 0x05	| 0xC600		| Remote Address
0x06		| ...			| Data Operation Length (length of History Data)
0x07		| 0x00			| Parameter
0x08		| ...			| Data Checksum
0x09 - 0x36	| ...			| History Data
0x37		| ...			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

The receiver returns the following ACK packet:

----------------------------------------------------------------------------------------------------------------------
Receiver Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x80			| Transfer Status
0x01		| 0x00			|
0x02 - 0x03	| 0xC500		| Local Address
0x04		| ...			| Length of History Data
0x05		| 0xC4			|
0x06		| ...			| Length of History Data
0x07		| 0x00			|
0x08		| ...			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

Finally, both sides are now ready to send the Raw File Data for a GBF file. The sender issues the Send File Data command for as many times as it takes to transfer the entire file. Each command can only transfer 256 bytes of file data at max. If the Data Operation Length is zero, that means the full 256 bytes are transferred. Any non-zero length indicates the very last bytes of a file, assuming it is not divisiable by 256. Additionally, the Parameter is always set to 0x01 while a file transfer is incomplete. The last transfer switches this parameter to 0x00.

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status
0x01		| 0x0A			| Command Byte (Send File Data)
0x02 - 0x03	| 0xC500		| Local Address
0x04 - 0x05	| 0xC600		| Remote Address
0x06		| ...			| Data Operation Length (0x00 = 256 bytes)
0x07		| 0x00 or 0x01		| Parameter (0x01 = Transfer in Progress, 0x00 = Final Transfer)
0x08		| ...			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

For every one of these commands, the receiver sends an ACK packet in response. The first one is used while the file transfer is in progress, while the second is used for the final transfer:

----------------------------------------------------------------------------------------------------------------------
Receiver Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x80			| Transfer Status
0x01		| 0x00			|
0x02 - 0x03	| 0xC500		| Local Address
0x04 - 0x05	| 0xC500 		| Remote Address
0x06		| 0x00			| 
0x07		| 0x01			| Parameter
0x08		| 0xF5			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------------------------------
Receiver Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x80			| Transfer Status
0x01		| 0x00			|
0x02 - 0x03	| 0xC500		| Local Address
0x04 - 0x05	| 0xC403 		| Remote Address
0x06		| 0x03			| 
0x07		| 0x00			| Parameter
0x08		| 0xF1			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

Once all the file data has been sent, the transfer is ended. There is a curious 16-bit value used after the Local Address, which is calculated as 0x03 - (File Size - Raw File Size). The command looks like this:

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status
0x01		| 0x04			| Command Byte (Start/Stop File Data Transfer)
0x02 - 0x03	| 0xC50B		| Local Address
0x04 - 0x05	| 0xFF0B		| 0x03 - (File Size - Raw File Size)
0x06		| 0x00			| Data Operation Length (no data sent)
0x07		| 0x00			| Parameter
0x08		| 0xF2			| Command Checksum
----------------------------------------------------------------------------------------------------------------------

Again, the receiver sends an ACK packet for the Start/Stop File Data Transfer command:

----------------------------------------------------------------------------------------------------------------------
Receiver Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x40			| Transfer Status
0x01		| 0x01			|
0x02 - 0x03	| 0xC500		| Local Address
0x04 - 0x05	| 0xFF0B		| 0x03 - (File Size - Raw File Size)
0x06 - 0x07	| ...			| Metadata Size
0x08		| ...			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

The last bit of data from the sender, oddly enough, is the Cartridge Code, Byte 0x03 of the GBF file:

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status
0x01		| 0x0A			| Command Byte (Send File Data)
0x02 - 0x03	| 0xC500		| Local Address
0x04 - 0x05	| 0xC50A		| Remote Address
0x06		| 0x01			| Data Operation Length
0x07		| 0x00			| Parameter
0x08		| 0x31			| Command Checksum
0x09		| ...			| Cartridge Code
0x0A		| ...			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

The receiver sends this ACK packet afterwards:

----------------------------------------------------------------------------------------------------------------------
Receiver Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x80			| Transfer Status
0x01		| 0x00			|
0x02 - 0x03	| 0xC500		| Local Address
0x04 - 0x05	| 0xC401 		| Remote Address
0x06		| 0x01			| 
0x07		| 0x00			| Parameter
0x08		| 0xF5			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

Before finishing up communications, the sender sets the Transfer End Flag with a Write Remote RAM command:

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status 
0x01		| 0x0B			| Command Byte (Write Remote RAM)
0x02 - 0x03	| 0xCE00		| Local Address
0x04 - 0x05	| 0xCE00		| Remote Address
0x06		| 0x01			| Data Operation Length
0x07		| 0x00			| Parameter
0x08		| 0x28			| Command Checksum
0x09		| 0x02			| Data Byte (Tranfer End Flag)
0x0A		| 0xFE			| Data Checksum
----------------------------------------------------------------------------------------------------------------------

The receiver responds with the Data Checksum value. Now the transfer is just about complete. The very last command from the sender ends the session. Note that the command is exactly the same as starting it. No parameters have changed:

----------------------------------------------------------------------------------------------------------------------
Sender Bytes	| Value			| Description
----------------------------------------------------------------------------------------------------------------------
0x00		| 0x30			| Transfer Status 
0x01		| 0x00			| Command Byte (Start/Stop Session)
0x02 - 0x03	| 0xCE00		| Local Address
0x04 - 0x05	| 0xCE00		| Remote Address
0x06		| 0x01			| Data Operation Length
0x07		| 0x00			| Parameter
0x08		| 0x33			| Command Checksum
----------------------------------------------------------------------------------------------------------------------



