vail/static/keyer.mjs

369 lines
7.8 KiB
JavaScript
Raw Normal View History

2021-04-26 14:33:48 -06:00
/** Silent period between words */
const PAUSE_WORD = -7
/** Silent period between letters */
const PAUSE_LETTER = -3
/** Silent period between dits and dash */
const PAUSE = -1
/** Duration of a dit */
const DIT = 1
/** Duration of a dah */
const DAH = 3
const MorseMap = {
"\x04": ".-.-.", // End Of Transmission
"\x18": "........", // Cancel
"0": "-----",
"1": ".----",
"2": "..---",
"3": "...--",
"4": "....-",
"5": ".....",
"6": "-....",
"7": "--...",
"8": "---..",
"9": "----.",
"a": ".-",
"b": "-...",
"c": "-.-.",
"d": "-..",
"e": ".",
"f": "..-.",
"g": "--.",
"h": "....",
"i": "..",
"j": ".---",
"k": "-.-",
"l": ".-..",
"m": "--",
"n": "-.",
"o": "---",
"p": ".--.",
"q": "--.-",
"r": ".-.",
"s": "...",
"t": "-",
"u": "..-",
"v": "...-",
"w": ".--",
"x": "-..-",
"y": "-.--",
"z": "--..",
".": ".-.-.-",
",": "--..--",
"?": "..--..",
"'": ".----.",
"!": "-.-.--",
"/": "-..-.",
"(": "-.--.",
")": "-.--.-",
"&": ".-...",
":": "---...",
";": "---...",
"=": "-...-",
"+": ".-.-.",
"-": "-....-",
"_": "--..-.",
"\"": ".-..-.",
"$": "...-..-",
"@": ".--.-.",
}
// iOS kludge
if (!window.AudioContext) {
window.AudioContext = window.webkitAudioContext
}
/**
* Return the inverse of the input.
* If you give it dit, it returns dah, and vice-versa.
*
* @param ditdah What to invert
* @returns The inverse of ditdah
*/
function morseNot(ditdah) {
if (ditdah == DIT) {
return DAH
}
return DIT
}
2021-04-26 14:33:48 -06:00
/**
* A callback to start or stop transmission
*
* @callback TxControl
*/
/**
2021-04-27 17:30:16 -06:00
* Keyer class. This handles iambic and straight key input.
2021-04-26 14:33:48 -06:00
*
* This will handle the following things that people appear to want with iambic input:
*
* - Typematic: you hold the key down and it repeats evenly-spaced tones
* - Typeahead: if you hit a key while it's still transmitting the last-entered one, it queues up your next entered one
*/
2021-04-27 17:30:16 -06:00
class Keyer {
2021-04-26 14:33:48 -06:00
/**
* Create a Keyer
2021-04-26 14:33:48 -06:00
*
2021-04-27 18:37:25 -06:00
* @param {TxControl} beginTxFunc Callback to begin transmitting
* @param {TxControl} endTxFunc Callback to end transmitting
2021-04-26 14:33:48 -06:00
* @param {number} intervalDuration Dit duration (milliseconds)
2021-04-27 18:37:25 -06:00
* @param {number} pauseMultiplier How long to stretch out inter-letter and inter-word pauses
2021-04-26 14:33:48 -06:00
*/
constructor(beginTxFunc, endTxFunc, {intervalDuration=100, pauseMultiplier=1}={}) {
2021-04-26 14:33:48 -06:00
this.beginTxFunc = beginTxFunc
this.endTxFunc = endTxFunc
this.intervalDuration = intervalDuration
this.pauseMultiplier = pauseMultiplier
2021-04-26 14:33:48 -06:00
this.ditDown = false
this.dahDown = false
this.typeahead = false
this.iambicModeB = true
2021-04-26 14:33:48 -06:00
this.last = null
this.queue = []
this.pulseTimer = null
}
pulse() {
if (this.queue.length == 0) {
let next = this.typematic()
if (next) {
// Barkeep! Another round!
this.Enqueue(next)
} else {
// Nothing left on the queue, stop the machine
this.pulseTimer = null
return
}
}
let next = this.queue.shift()
if (next < 0) {
next *= -1
if (next > 1) {
// Don't adjust spacing within a letter
next *= this.pauseMultiplier
} else {
this.endTxFunc()
2022-04-24 17:13:56 -06:00
if (this.txChart) {
this.txChart.Add(Date.now(), 0)
}
}
2021-04-26 14:33:48 -06:00
} else {
this.last = next
this.beginTxFunc()
2022-04-24 17:13:56 -06:00
if (this.txChart) {
this.txChart.Add(Date.now(), 1)
}
2021-04-26 14:33:48 -06:00
}
this.pulseTimer = setTimeout(() => this.pulse(), next * this.intervalDuration)
}
maybePulse() {
// If there's no timer running right now, restart the pulse
if (!this.pulseTimer) {
this.pulse()
}
}
typematic() {
if (this.ditDown && this.dahDown) {
this.modeBQueue = this.last
this.last = morseNot(this.last)
2021-04-26 14:33:48 -06:00
} else if (this.ditDown) {
this.modeBQueue = null
2021-04-26 14:33:48 -06:00
this.last = DIT
} else if (this.dahDown) {
this.modeBQueue = null
2021-04-26 14:33:48 -06:00
this.last = DAH
} else if (this.modeBQueue && this.iambicModeB) {
this.last = this.modeBQueue
this.modeBQueue = null
2021-04-26 14:33:48 -06:00
} else {
this.last = null
this.modeBQueue = null
2021-04-26 14:33:48 -06:00
}
return this.last
}
/**
* Return true if we are currently playing out something
*/
Busy() {
return this.pulseTimer
}
2021-04-27 17:30:16 -06:00
2021-04-26 14:33:48 -06:00
/**
* Set a new dit interval (transmission rate)
*
* @param {number} duration Dit duration (milliseconds)
*/
SetIntervalDuration(duration) {
this.intervalDuration = duration
}
/**
* Set a new pause multiplier.
*
* This slows down the inter-letter and inter-word pauses,
* which can aid in learning.
*
* @param {number} multiplier Pause multiplier
*/
SetPauseMultiplier(multiplier) {
this.pauseMultiplier = multiplier
}
/**
* Set Iambic mode B.
*
* Near as I can tell, B sends one more tone than was entered, when
* both keys are held down.
* This logic happens in the typematic code.
*
* Dit key
*
* Dah key
*
* Mode A output
*
* Mode B output
*
* @param {boolean} value True to set mode to B
*/
SetIambicModeB(value) {
this.iambicModeB = Boolean(value)
}
/**
* Enable/disable typeahead.
*
* Typeahead maintains a key buffer, so you can key in dits and dahs faster than the
* Iambic keyer can play them out.
*
* Some people apparently expect this behavior, and have trouble if it isn't enabled.
* For others, having this enabled makes it feel like they have a "phantom keyer"
* entering keys they did not send.
*
* @param value True to enable typeahead
*/
SetTypeahead(value) {
this.typeahead = value
}
2021-04-28 14:28:59 -06:00
/**
* Delete anything left on the queue.
*/
Flush() {
this.queue.splice(0)
}
2021-04-26 14:33:48 -06:00
/**
* Add to the output queue, and start processing the queue if it's not currently being processed.
*
* @param {number} key A duration, in dits. Negative durations are silent.
*/
Enqueue(key) {
this.queue.push(key)
if (key > 0) {
this.queue.push(PAUSE)
}
this.maybePulse()
}
2021-04-27 18:37:25 -06:00
/**
* Enqueue a morse code string (eg "... --- ...")
*
* @param {string} ms String to enqueue
*/
2021-04-26 14:33:48 -06:00
EnqueueMorseString(ms) {
for (let mc of ms) {
switch (mc) {
case ".":
this.Enqueue(DIT)
break
case "-":
this.Enqueue(DAH)
break
case " ":
this.Enqueue(PAUSE_LETTER)
break
}
}
}
2021-04-27 18:37:25 -06:00
/**
* Enqueue an ASCII string (eg "SOS help")
*
* @param {string} s String to enqueue
*/
EnqueueAsciiString(s, {pauseLetter = PAUSE_LETTER, pauseWord = PAUSE_WORD} = {}) {
2021-04-26 14:33:48 -06:00
for (let c of s.toLowerCase()) {
let m = MorseMap[c]
if (m) {
this.EnqueueMorseString(m)
this.Enqueue(pauseLetter)
2021-04-26 14:33:48 -06:00
continue
}
switch (c) {
case " ":
case "\n":
case "\t":
this.Enqueue(pauseWord)
2021-04-26 14:33:48 -06:00
break
default:
console.warn("Unable to encode '" + c + "'!")
break
}
}
}
/**
2021-04-27 17:30:16 -06:00
* Do something to the straight key
*
* @param down True if key was pressed
*/
Straight(down) {
if (down) {
this.beginTxFunc()
} else {
this.endTxFunc()
2021-04-26 14:33:48 -06:00
}
2021-04-27 17:30:16 -06:00
}
/**
* Do something to the dit key
*
* @param down True if key was pressed
*/
Dit(down) {
this.ditDown = down
2022-04-23 21:23:05 -06:00
if (down) {
if (this.typeahead
|| !this.Busy()
|| (this.iambicModeB && (this.last == DAH))) {
this.Enqueue(DIT)
}
2021-04-27 17:30:16 -06:00
}
}
2021-04-26 14:33:48 -06:00
2021-04-27 17:30:16 -06:00
/**
* Do something to the dah key
*
* @param down True if key was pressed
*/
Dah(down) {
this.dahDown = down
2022-04-23 21:23:05 -06:00
if (down) {
if (this.typeahead
|| !this.Busy()
|| (this.iambicModeB && (this.last == DIT))) {
this.Enqueue(DAH)
}
2021-04-26 14:33:48 -06:00
}
2021-04-27 17:30:16 -06:00
}
2021-04-26 14:33:48 -06:00
}
export {Keyer}