gr-satnogs/lib/morse_debug_source_impl.cc

/* -*- c++ -*- */
/*
 * gr-satnogs: SatNOGS GNU Radio Out-Of-Tree Module
 *
 *  Copyright (C) 2016, 2017
 *  Libre Space Foundation <http://librespacefoundation.org/>
 *
 *  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, either 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 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/>.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <gnuradio/io_signature.h>
#include "morse_debug_source_impl.h"
#include <satnogs/morse.h>
#include <random>

namespace gr {
namespace satnogs {

morse_debug_source::sptr
morse_debug_source::make(const size_t wpm,
                         const std::string &debug_seq, bool inject_errors,
                         float error_prob,
                         size_t seq_pause_ms)
{
  return gnuradio::get_initial_sptr(
           new morse_debug_source_impl(wpm, debug_seq, inject_errors,
                                       error_prob, seq_pause_ms));
}

/*
 * The private constructor
 */
morse_debug_source_impl::morse_debug_source_impl(const size_t wpm,
    std::string debug_seq,
    bool inject_errors,
    float error_prob,
    size_t seq_pause_ms) :
  gr::block("morse_debug_source",
            gr::io_signature::make(0, 0, 0),
            gr::io_signature::make(0, 0, 0)),
  d_wpm(wpm),
  d_inject_errors(inject_errors),
  d_p(error_prob),
  d_seq_pause_ms(seq_pause_ms),
  d_run(true),
  d_chars {
  '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', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0' },
d_symbols {
  ".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..",
  ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-",
  ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--",
  "--..", ".----", "..---", "...--", "....-", ".....", "-....",
  "--...", "---..", "----.", "-----" }
{
  message_port_register_out(pmt::mp("out"));
  d_thread = std::thread(&morse_debug_source_impl::send_debug_msg, this,
                         debug_seq);
}

static inline size_t
find_char_idx(const char *characters, size_t len, char c)
{
  size_t i;
  for (i = 0; i < len; i++) {
    if (characters[i] == c) {
      return i;
    }
  }
  return len;
}

void
morse_debug_source_impl::send_debug_msg(std::string sentence)
{
  size_t i;
  size_t j;
  size_t idx;
  std::string s;
  char c;
  std::random_device rd;
  std::mt19937 gen(rd());
  std::bernoulli_distribution error_distr(d_p);
  bool inject_error;
  size_t len = sentence.length();
  pmt::pmt_t port = pmt::mp("out");

  std::this_thread::sleep_for(std::chrono::milliseconds(1000));

  while (d_run) {
    /* Not the best approach, but hey, this is only for debug */
    for (i = 0; i < len; i++) {
      c = std::toupper(sentence[i]);
      if (c == ' ') {
        message_port_pub(port, pmt::from_long(MORSE_L_SPACE));
      }

      idx = find_char_idx(d_chars, sizeof(d_chars), c);
      if (idx != sizeof(d_chars)) {

        s = d_symbols[idx];
        /* Get from the random distribution if an error should be injected */
        inject_error = d_inject_errors && error_distr(gen);
        for (j = 0; j < s.length(); j++) {
          if (s[j] == '.') {
            if (inject_error) {
              message_port_pub(port, pmt::from_long(MORSE_DASH));
              message_port_pub(port, pmt::from_long(MORSE_INTRA_SPACE));

            }
            else {
              message_port_pub(port, pmt::from_long(MORSE_DOT));
              message_port_pub(port, pmt::from_long(MORSE_INTRA_SPACE));
            }
          }
          else {
            if (inject_error) {
              message_port_pub(port, pmt::from_long(MORSE_DOT));
              message_port_pub(port, pmt::from_long(MORSE_INTRA_SPACE));
            }
            else {
              message_port_pub(port, pmt::from_long(MORSE_DASH));
              message_port_pub(port, pmt::from_long(MORSE_INTRA_SPACE));
            }
          }
          std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }

        /* Send also a character delimiter */
        message_port_pub(port, pmt::from_long(MORSE_S_SPACE));
      }
    }
    message_port_pub(port, pmt::from_long(MORSE_L_SPACE));

    for (i = 0; i < d_seq_pause_ms / (1200 / d_wpm); i++) {
      message_port_pub(port, pmt::from_long(MORSE_INTRA_SPACE));
    }

    /* Perform a true sleep, to avoid message overload */
    std::this_thread::sleep_for(std::chrono::milliseconds(d_seq_pause_ms));
  }
}

/*
 * Our virtual destructor.
 */
morse_debug_source_impl::~morse_debug_source_impl()
{
  d_run = false;
  d_thread.join();
}

} /* namespace satnogs */
} /* namespace gr */