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:
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
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
|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
Low level function, you will use it rarely (such as tuning PA function)
|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
|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
|5||Tail time in 5 mSec steps||Time between last dot/dash is ended and PTT returns to off||CMD_SET_TAIL_TIME||Immediate
|6||Hang time in word lengths||Time, in percent, of a
word length before it is switched to RX
when sending by hand
|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
4: speed potentiometer
|If the bit is set the
feature is enabled. If the bit is cleared the feature is
By default all features are enabled.
(all features enabled)
|9||0: paddles don't trigger
>0: paddles do trigger PTT
|Determines whether manual
sending will trigger PTT.
For extremely long lead times you may need to switch this off.
|10||Pitch of the side-tone
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
|11||Pitch of the side-tone
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
|12||0: Curtis-A (no dit/dash
1: Curtis-B (paddles buffered)
|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
|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).
|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.
|19||0: don't send the status
>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
|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
|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
|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
|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
|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.
|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
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.
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.
|bit 7 (MSB)||always 1||any|
|bit 6||not used (reserved)||any|
|bit 5||0: no characters in the
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
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:
handle = CreateFile(a, GENERIC_READ or GENERIC_WRITE, 0, Nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)
where a is the COM designation, such as "COM8", or "\\.\COM22"
Set properties of
COM, incl. speed:
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
(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):
< Spider Keyer Main Page
<< Return to Main Page