|
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
// Copyright (C) 2023 Jon Beniston, M7RCE <jon@beniston.com> // |
|
|
// // |
|
|
// This program is free software; you can redistribute it and/or modify // |
|
|
// it under the terms of the GNU General Public License as published by // |
|
|
// the Free Software Foundation as version 3 of the License, or // |
|
|
// (at your option) any later version. // |
|
|
// // |
|
|
// This program is distributed in the hope that it will be useful, // |
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // |
|
|
// GNU General Public License V3 for more details. // |
|
|
// // |
|
|
// You should have received a copy of the GNU General Public License // |
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
|
|
#include <QDebug> |
|
|
|
|
|
#include "baudot.h" |
|
|
|
|
|
// https://en.wikipedia.org/wiki/Baudot_code |
|
|
// We use < for FIGS and > for LTRS and ^ for Cyrillic |
|
|
// Unicode used for source file encoding |
|
|
|
|
|
const QStringList Baudot::m_ita2Letter = { |
|
|
"\0", "E", "\n", "A", " ", "S", "I", "U", |
|
|
"\r", "D", "R", "J", "N", "F", "C", "K", |
|
|
"T", "Z", "L", "W", "H", "Y", "P", "Q", |
|
|
"O", "B", "G", "<", "M", "X", "V", ">" |
|
|
}; |
|
|
|
|
|
const QStringList Baudot::m_ita2Figure = { |
|
|
"\0", "3", "\n", "-", " ", "\'", "8", "7", |
|
|
"\r", "\x5", "4", "\a", ",", "!", ":", "(", |
|
|
"5", "+", ")", "2", "£", "6", "0", "1", |
|
|
"9", "?", "&", "<", ".", "/", "=", ">" |
|
|
}; |
|
|
|
|
|
const QStringList Baudot::m_ukLetter = { |
|
|
"\0", "A", "E", "/", "Y", "U", "I", "O", |
|
|
"<", "J", "G", "H", "B", "C", "F", "D", |
|
|
" ", "-", "X", "Z", "S", "T", "W", "V", |
|
|
"\b", "K", "M", "L", "R", "Q", "N", "P" |
|
|
}; |
|
|
|
|
|
const QStringList Baudot::m_ukFigure = { |
|
|
"\0", "1", "2", "⅟", "3", "4", "³⁄", "5", |
|
|
" ", "6", "7", "¹", "8", "9", "⁵⁄", "0", |
|
|
">", ".", "⁹⁄", ":", "⁷⁄", "²", "?", "\'", |
|
|
"\b", "(", ")", "=", "-", "/", "£", "+" |
|
|
}; |
|
|
|
|
|
const QStringList Baudot::m_europeanLetter = { |
|
|
"\0", "A", "E", "É", "Y", "U", "I", "O", |
|
|
"<", "J", "G", "H", "B", "C", "F", "D", |
|
|
" ", "t", "X", "Z", "S", "T", "W", "V", |
|
|
"\b", "K", "M", "L", "R", "Q", "N", "P" |
|
|
}; |
|
|
|
|
|
const QStringList Baudot::m_europeanFigure = { |
|
|
"\0", "1", "2", "&", "3", "4", "º", "5", |
|
|
" ", "6", "7", "H̱", "8", "9", "F̱", "0", |
|
|
">", ".", ",", ":", ";", "!", "?", "\'", |
|
|
"\b", "(", ")", "=", "-", "/", "№", "%" |
|
|
}; |
|
|
|
|
|
const QStringList Baudot::m_usLetter = { |
|
|
"\0", "E", "\n", "A", " ", "S", "I", "U", |
|
|
"\r", "D", "R", "J", "N", "F", "C", "K", |
|
|
"T", "Z", "L", "W", "H", "Y", "P", "Q", |
|
|
"O", "B", "G", "<", "M", "X", "V", ">" |
|
|
}; |
|
|
|
|
|
const QStringList Baudot::m_usFigure = { |
|
|
"\0", "3", "\n", "-", " ", "\a", "8", "7", |
|
|
"\r", "\x5", "4", "\'", ",", "!", ":", "(", |
|
|
"5", "\"", ")", "2", "#", "6", "0", "1", |
|
|
"9", "?", "&", "<", ".", "/", ";", ">" |
|
|
}; |
|
|
|
|
|
const QStringList Baudot::m_russianLetter = { |
|
|
"\0", "Е", "\n", "А", " ", "С", "И", "У", |
|
|
"\r", "Д", "Р", "Й", "Ч", "Ф", "Ц", "К", |
|
|
"Т", "З", "Л", "В", "Х", "Ы", "П", "Я", |
|
|
"О", "Б", "Г", "<", "М", "Ь", "Ж", ">" |
|
|
}; |
|
|
|
|
|
const QStringList Baudot::m_russianFigure = { |
|
|
"\0", "3", "\n", "-", " ", "\'", "8", "7", |
|
|
"\r", "Ч", "4", "Ю", ",", "Э", ":", "(", |
|
|
"5", "+", ")", "2", "Щ", "6", "0", "1", |
|
|
"9", "?", "Ш", "<", ".", "/", ";", ">" |
|
|
}; |
|
|
|
|
|
const QStringList Baudot::m_murrayLetter = { |
|
|
" ", "E", "?", "A", ">", "S", "I", "U", |
|
|
"\n", "D", "R", "J", "N", "F", "C", "K", |
|
|
"T", "Z", "L", "W", "H", "Y", "P", "Q", |
|
|
"O", "B", "G", "<", "M", "X", "V", "\b" |
|
|
}; |
|
|
|
|
|
const QStringList Baudot::m_murrayFigure = { |
|
|
" ", "3", "?", " ", ">", "'", "8", "7", |
|
|
"\n", "²", "4", "⁷⁄", "-", "⅟", "(", "⁹⁄", |
|
|
"5", ".", "/", "2", "⁵⁄", "6", "0", "1", |
|
|
"9", "?", "³⁄", "<", ",", "£", ")", "\b" |
|
|
}; |
|
|
|
|
|
BaudotDecoder::BaudotDecoder() |
|
|
{ |
|
|
setCharacterSet(Baudot::ITA2); |
|
|
setUnshiftOnSpace(false); |
|
|
init(); |
|
|
} |
|
|
|
|
|
void BaudotDecoder::setCharacterSet(Baudot::CharacterSet characterSet) |
|
|
{ |
|
|
m_characterSet = characterSet; |
|
|
switch (m_characterSet) |
|
|
{ |
|
|
case Baudot::ITA2: |
|
|
m_letters = Baudot::m_ita2Letter; |
|
|
m_figures = Baudot::m_ita2Figure; |
|
|
break; |
|
|
case Baudot::UK: |
|
|
m_letters = Baudot::m_ukLetter; |
|
|
m_figures = Baudot::m_ukFigure; |
|
|
break; |
|
|
case Baudot::EUROPEAN: |
|
|
m_letters = Baudot::m_europeanLetter; |
|
|
m_figures = Baudot::m_europeanFigure; |
|
|
break; |
|
|
case Baudot::US: |
|
|
m_letters = Baudot::m_usLetter; |
|
|
m_figures = Baudot::m_usFigure; |
|
|
break; |
|
|
case Baudot::RUSSIAN: |
|
|
m_letters = Baudot::m_russianLetter; |
|
|
m_figures = Baudot::m_russianFigure; |
|
|
break; |
|
|
case Baudot::MURRAY: |
|
|
m_letters = Baudot::m_murrayLetter; |
|
|
m_figures = Baudot::m_murrayFigure; |
|
|
break; |
|
|
default: |
|
|
qDebug() << "BaudotDecoder::BaudotDecoder: Unsupported character set " << m_characterSet; |
|
|
m_letters = Baudot::m_ita2Letter; |
|
|
m_figures = Baudot::m_ita2Figure; |
|
|
m_characterSet = Baudot::ITA2; |
|
|
break; |
|
|
} |
|
|
} |
|
|
|
|
|
void BaudotDecoder::setUnshiftOnSpace(bool unshiftOnSpace) |
|
|
{ |
|
|
m_unshiftOnSpace = unshiftOnSpace; |
|
|
} |
|
|
|
|
|
void BaudotDecoder::init() |
|
|
{ |
|
|
m_figure = false; |
|
|
} |
|
|
|
|
|
QString BaudotDecoder::decode(char bits) |
|
|
{ |
|
|
QString c = m_figure ? m_figures[(int)bits] : m_letters[(int)bits]; |
|
|
|
|
|
if ((c == ">") || (m_unshiftOnSpace && (c == " "))) |
|
|
{ |
|
|
// Switch to letters |
|
|
m_figure = false; |
|
|
if (m_characterSet == Baudot::RUSSIAN) { |
|
|
m_letters = Baudot::m_ita2Letter; |
|
|
} |
|
|
} |
|
|
if (c == "<") |
|
|
{ |
|
|
// Switch to figures |
|
|
m_figure = true; |
|
|
} |
|
|
if ((m_characterSet == Baudot::RUSSIAN) && (c == "\0")) |
|
|
{ |
|
|
// Switch to Cyrillic |
|
|
m_figure = false; |
|
|
m_letters = Baudot::m_russianLetter; |
|
|
c = "^"; |
|
|
} |
|
|
|
|
|
return c; |
|
|
} |
|
|
|
|
|
BaudotEncoder::BaudotEncoder() |
|
|
{ |
|
|
setCharacterSet(Baudot::ITA2); |
|
|
setUnshiftOnSpace(false); |
|
|
setMsbFirst(false); |
|
|
setStartBits(1); |
|
|
setStopBits(1); |
|
|
init(); |
|
|
} |
|
|
|
|
|
void BaudotEncoder::setCharacterSet(Baudot::CharacterSet characterSet) |
|
|
{ |
|
|
m_characterSet = characterSet; |
|
|
switch (m_characterSet) |
|
|
{ |
|
|
case Baudot::ITA2: |
|
|
m_chars[LETTERS] = Baudot::m_ita2Letter; |
|
|
m_chars[FIGURES] = Baudot::m_ita2Figure; |
|
|
break; |
|
|
case Baudot::UK: |
|
|
m_chars[LETTERS] = Baudot::m_ukLetter; |
|
|
m_chars[FIGURES] = Baudot::m_ukFigure; |
|
|
break; |
|
|
case Baudot::EUROPEAN: |
|
|
m_chars[LETTERS] = Baudot::m_europeanLetter; |
|
|
m_chars[FIGURES] = Baudot::m_europeanFigure; |
|
|
break; |
|
|
case Baudot::US: |
|
|
m_chars[LETTERS] = Baudot::m_usLetter; |
|
|
m_chars[FIGURES] = Baudot::m_usFigure; |
|
|
break; |
|
|
case Baudot::RUSSIAN: |
|
|
m_chars[LETTERS] = Baudot::m_ita2Letter; |
|
|
m_chars[FIGURES] = Baudot::m_russianFigure; |
|
|
break; |
|
|
case Baudot::MURRAY: |
|
|
m_chars[LETTERS] = Baudot::m_murrayLetter; |
|
|
m_chars[FIGURES] = Baudot::m_murrayFigure; |
|
|
break; |
|
|
default: |
|
|
qDebug() << "BaudotEncoder::BaudotEncoder: Unsupported character set " << m_characterSet; |
|
|
m_chars[LETTERS] = Baudot::m_ita2Letter; |
|
|
m_chars[FIGURES] = Baudot::m_ita2Figure; |
|
|
m_characterSet = Baudot::ITA2; |
|
|
break; |
|
|
} |
|
|
m_chars[(int)CYRILLIC] = Baudot::m_russianLetter; |
|
|
} |
|
|
|
|
|
void BaudotEncoder::setUnshiftOnSpace(bool unshiftOnSpace) |
|
|
{ |
|
|
m_unshiftOnSpace = unshiftOnSpace; |
|
|
} |
|
|
|
|
|
void BaudotEncoder::setMsbFirst(bool msbFirst) |
|
|
{ |
|
|
m_msbFirst = msbFirst; |
|
|
} |
|
|
|
|
|
// startBits should be 0 or 1 |
|
|
void BaudotEncoder::setStartBits(int startBits) |
|
|
{ |
|
|
m_startBits = startBits; |
|
|
} |
|
|
|
|
|
// stopBits should be 0, 1 or 2 |
|
|
void BaudotEncoder::setStopBits(int stopBits) |
|
|
{ |
|
|
m_stopBits = stopBits; |
|
|
} |
|
|
|
|
|
void BaudotEncoder::init() |
|
|
{ |
|
|
m_page = LETTERS; |
|
|
} |
|
|
|
|
|
bool BaudotEncoder::encode(QChar c, unsigned &bits, unsigned int &bitCount) |
|
|
{ |
|
|
bits = 0; |
|
|
bitCount = 0; |
|
|
|
|
|
// Only upper case is supported |
|
|
c = c.toUpper(); |
|
|
QString s(c); |
|
|
|
|
|
if (s == '>') |
|
|
{ |
|
|
addCode(bits, bitCount, m_chars[m_page].indexOf(s)); |
|
|
m_page = LETTERS; |
|
|
return true; |
|
|
} |
|
|
else if (s == '<') |
|
|
{ |
|
|
addCode(bits, bitCount, m_chars[m_page].indexOf(s)); |
|
|
m_page = FIGURES; |
|
|
return true; |
|
|
} |
|
|
else if ((m_characterSet == Baudot::RUSSIAN) && (s == '\0')) |
|
|
{ |
|
|
addCode(bits, bitCount, m_chars[m_page].indexOf(s)); |
|
|
m_page = CYRILLIC; |
|
|
return true; |
|
|
} |
|
|
|
|
|
// We could create reverse look-up tables to speed this up, but it's only 200 baud... |
|
|
|
|
|
// Is character in current page? If so, use that, as it avoids switching |
|
|
if (m_chars[m_page].contains(s)) |
|
|
{ |
|
|
addCode(bits, bitCount, m_chars[m_page].indexOf(s)); |
|
|
return true; |
|
|
} |
|
|
else |
|
|
{ |
|
|
// Look for character in other pages |
|
|
const QString switchPage[] = { ">", "<", "\0" }; |
|
|
|
|
|
for (int page = m_page == LETTERS ? 1 : 0; page < ((m_characterSet == Baudot::RUSSIAN) ? 3 : 2); page++) |
|
|
{ |
|
|
if (m_chars[page].contains(s)) |
|
|
{ |
|
|
// Switch to page |
|
|
addCode(bits, bitCount, m_chars[m_page].indexOf(switchPage[page])); |
|
|
m_page = (BaudotEncoder::Page)page; |
|
|
|
|
|
addCode(bits, bitCount, m_chars[m_page].indexOf(s)); |
|
|
return true; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
return false; |
|
|
} |
|
|
|
|
|
void BaudotEncoder::addCode(unsigned& bits, unsigned int& bitCount, unsigned int code) const |
|
|
{ |
|
|
const unsigned int codeLen = 5; |
|
|
|
|
|
addStartBits(bits, bitCount); |
|
|
code = reverseBits(code, codeLen); |
|
|
addBits(bits, bitCount, code, codeLen); |
|
|
addStopBits(bits, bitCount); |
|
|
} |
|
|
|
|
|
void BaudotEncoder::addStartBits(unsigned& bits, unsigned int& bitCount) const |
|
|
{ |
|
|
// Start bit is 0 |
|
|
addBits(bits, bitCount, 0, m_startBits); |
|
|
} |
|
|
|
|
|
void BaudotEncoder::addStopBits(unsigned& bits, unsigned int& bitCount) const |
|
|
{ |
|
|
// Stop bit is 1 |
|
|
addBits(bits, bitCount, ((1 << m_stopBits)) - 1, m_stopBits); |
|
|
} |
|
|
|
|
|
void BaudotEncoder::addBits(unsigned& bits, unsigned int& bitCount, int data, int count) const |
|
|
{ |
|
|
bits |= data << bitCount; |
|
|
bitCount += count; |
|
|
} |
|
|
|
|
|
unsigned BaudotEncoder::reverseBits(unsigned bits, unsigned int count) const |
|
|
{ |
|
|
if (m_msbFirst) { |
|
|
return BaudotEncoder::reverse(bits) >> (sizeof(unsigned int) * 8 - count); |
|
|
} else { |
|
|
return bits; |
|
|
} |
|
|
} |
|
|
|
|
|
unsigned int BaudotEncoder::reverse(unsigned int x) |
|
|
{ |
|
|
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1)); |
|
|
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2)); |
|
|
x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4)); |
|
|
x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8)); |
|
|
|
|
|
return((x >> 16) | (x << 16)); |
|
|
}
|
|
|
|