Spider Keyer Specifications


Schematics (ver 2.0)
Schematics (ver 3.0)

Communication with the PC

To communicate with Spider Keyer set a COM port to: speed 57600 bps, no parity, 8 data bits, 2 stop bits.

Characters to transmit must be sent in upper case. Besides these Spider Keyer can receive commands. Each command consists of two consecutive bytes. Byte1 determinates the command, Byte2 carries optional data.

Buffered and immediate commands

The unit stores the command into an internal buffer when it is received. It is the same buffer where it stores characters to send. It is executed when it is its turn while playing the buffer.
If the command is preceeded with byte with the value 27 (Esc) then the command is not stored into the buffer but it is executed immediately when it arrives.

For example, the command CMD_SPEED_CHANGE can be used in the two ways:

Startup commands

Some of the commands change values that the keyer will use until it is changed again or the keyer is restarted (typically the lead time). You will probably send a sequence of these commands once right after connecting to the keyer.
Hint: after connecting to Spider Keyer you may first send a sequence of startup command and, as a last item, you enable sending the reporting bytes (see further).

Implemented commands to be sent from PC
Byte1 Byte2 Meaning Referenced as To be used Default Sketch
1 0: PTT OFF
>0: PTT ON
Switch PTT on and off.
Low level function, you will use rarely, if ever
CMD_SET_PTT Immediate 0 1.01
2 0: Key up
1: Key down, don't toggle PTT
2: Key down and toggle PTT (incl. lead time)
Push the key or release it.
Low level function, you will use it rarely (such as tuning PA function)
CMD_SET_KEY Immediate 0 1.01
3 CW speed in WPM
0: clear the buffered speed change
255: set to speed determined by potentiometer
Default range is 15...40 wpm.. CMD_SPEED_CHANGE Immediate
determined by
4 Lead time in 5 mSec steps Time between PTT is set on and the first dot/dash is transmitted CMD_SET_LEAD_TIME Immediate
30 mSec 1.01
5 Tail time in 5 mSec steps Time between last dot/dash is ended and PTT returns to off CMD_SET_TAIL_TIME Immediate
5 mSec 1.01
6 Hang time in word lengths Time, in percent, of a word length before it is switched to RX
when sending by hand
90 1.01
7 Weighting 50 means normal weighting. Set to slighly higher value (e.g. 55) to make the dots/dashes bolder, and vice versa CMD_SET_WEIGHTING Immediate
50 1.01
8 Bitwise:
1: PTT
2: key
4: speed potentiometer
If the bit is set the feature is enabled. If the bit is cleared the feature is disabled.
By default all features are enabled.
(all features enabled)
9 0: paddles don't trigger PTT
>0: paddles do trigger PTT
Determines whether manual sending will trigger PTT.
For extremely long lead times you may need to switch this off.
1 (on) 1.01
10 Pitch of the side-tone for automatic
sending, in 10 Hz steps.
0: side-tone is switched off
This is the sound emitted by the buzzer on the PCB CMD_SET_SIDETONE_AUTOMATIC Immediate
750 1.01
11 Pitch of the side-tone for manual
sending, in 10 Hz steps.
0: side-tone is switched off
This is the sound emitted by the buzzer on the PCB CMD_SET_SIDETONE_MANUAL Immediate
750 1.01
12 0: Curtis-A (no dit/dash buffers)
1: Curtis-B (paddles buffered)
1 (Curtis-B) 1.01
14 Any Breaks automatic transmission CMD_BREAK_IMMY Immediate n/a 1.01
15 Any Software reset of the unit. All values return to "factory defaults" CMD_RESET Immediate n/a 1.01
16 Any Retrieves two status reporting bytes from the unit CMD_PING Immediate
n/a 1.01
17 Any Retrieves a short textual information from Spider Keyer.
Serves as a confirmation that the proper sketch was burned
into the unit (Arduino Nano).
n/a 1.01
18 Any Emits a short high-pitched beep by the buzzer on the PCB.
Can be used as a confirmation that serial communication works both ways.
CMD_BEEP Immediate
n/a 1.01
19 0: don't send the status bytes
>0: do send the status bytes
Determines whether the unit will send the two status reporting bytes or not. For example, the unit sends these bytes when the user rotates the Speed potentiometer. CMD_SET_FEEDBACK Immediate
0 (off) 1.01
20 cw speed in WPM
0: return to default (15 WPM)
Sets the lower limit for CW speed (button on Spider Keyer fully CCW). CMD_SET_LOW_LIMIT Immediate
15 1.02
21 cw speed in WPM
0: return to default (40 WPM)
Sets the higher limit for CW speed (button on Spider Keyer fully CW). CMD_SET_HIGH_LIMIT Immediate
40 1.02
22 0: no limitation takes place, otherwise CW speed in WPM Sets the limit of the manual sending. It has no impact on the automatic sending. The change to lower speed happens when the paddles are touched. CMD_SET_MANUAL_SENDING_LIMIT Immediate
0 (off) 1.10
23 0: don't swap paddles
>0: do swap paddles
Swappes paddles. When on the left paddle sends dashes and the right paddle sends dots. It can be convenient for left handed operators or if the operator does keying in an upside down position for some reason. It is also convenient for operators from Ricany, Czech Republic. CMD_SET_PADDLES_SWAPPED Immediate
0 (off) 1.20
(Oct 2020)
24 0: return to defaults
>0: save the current values
Saves the current settings to EEPROM memory. Spider Keyer initiates to values from EEPROM if they were stored there previously. This way it is possible to obtain the same behaviour of the keyer when it runs stand-alone (not connected to PC). It concers values like keyer mode (Curtis-A or Curtis-B), lead time, hang time, side tone, paddles swapped, etc.
Value 0 returns to the "factory" defaults.
CMD_SAVE_CONFIG On request n/a 1.30
(Dec 2020)
25 0: delete the whole message from EEPROM
>0: save the character to the end of the message in EEPROM
Stores a message into Spider Keyer EEPROM memory. This is the message which sent when a button on Spider Keyer is hit (it needs PCB version 3).
To store a new message into SK the controlling application must first send the command with Byte2 equal to zero to delete the previous message. Then for each character in the new message the command must be sent with Byte2 equal to the value of the character to store.
The new message is stored character by character.
For a long message you may need to insert some delay (try 50 mSec) between characters for Arduino to receive the larger data correctly.
CMD_STORE_MSG On request n/a 1.31
(Jan 2021)

Reporting bytes

The keyer can send back reporting bytes. This way the unit can inform the controlling PC application of some events. For example, the user changed the speed by rotating the speed potentiometer. For each event it sends two consecutive bytes. The sending reporting bytes must be enabled first by the command CMD_SET_FEEDBACK. The command CMD_PING retrieves the reporting bytes unconditionally.

For example, if the controlling PC application needs to learn when the sending is over it must trap bytes with bit 7 set (which indicates that it is the first reporting byte). If both bits 4 and 5 are cleared in this byte it can be reliably assumed that no transmission happens any longer.

Reporting bytes
Byte Bits Meaning Version
bit 7 (MSB) always 1 any
bit 6 not used (reserved) any
bit 5 0: no characters in the buffer
1: one or more characteres buffered
bit 4 0: PTT is currently OFF
1: PTT is currently ON
bit 3 0: Key is currently up
1: Key is currently down
(to reduce number of reporting bytes this works only for
the command CMD_SET_KEY)
bit 2 0: all the buffered text was transmitted
1: last sending was interrupted by touching the paddles
1.15 and higher
bit 1 not used (reserved)  
bit 0 (LSB) not used (reserved)  
bit 7 (MSB) always 0 any
bit 0 ... 6 0: the speed was changed by immedate command CMD_SPEED_CHANGE
>0: the current speed in wpm if it was set by rotating the potentiometer


Sending commands to the serial line

There many ways how to send characters to the serial line (COM). It depends on the operating system, programming language, etc. The following description concerns WinAPI commands. It will look the same or very similar in most programming languages.

Get handle to the file (COM) to use:
where a is the COM designation, such as "COM8", or "\\.\COM22"

Set properties of COM, incl. speed:
SetCommState(handle, DCB)
where DCB is the structure set to "57600,n,8,2"

Since now you can send characters to the serial line:
WriteFile(handle, to_be_sent, chars_to_send, chars_sent, null)
where to_be_sent is an array of bytes (characters) to be sent to the serial line
chars_to_send is the number of bytes to be sent
chars_sent is the number of bytes that were actually sent

When the line is open you may need to send a start-up sequence of commands to set Spider Keyer properties:
(all values decimal)

27 04 nn - set lead time
27 05 nn - set tail time
27 10 nn - set side tone (pitch of the buzzer) for automatic sending
27 11 nn - set side tone for manual sending
27 09 nn - set whether paddles will trigger PTT
27 12 nn - set the mode of hand keying (Curtis-A or Curtis-B)
27 03 nn - set CW speed (if not sent the speed is controlled by the potentiometer)
27 19 nn - set whether Spider Keyer will send the reporting bytes back to the serial line

Then you can send the characters to be transmitted. Mind that all characters must be in uppercase:
(all values decimal):

C Q   C Q   D E   ...
67    81    20    67    81    20    68    69    20   ...


< Spider Keyer Main Page

< Other Projects
<< Return to Main Page