cw 0.3.1 → 0.3.2

data/lib/cw/play.rb

@@ -72,7 +72,7 @@ module CWG
         end
         sleep 0.01
       end
-      Cfg.config["exit"] = true
+      #      Cfg.config["exit"] = true
       sleep 0.1
     end
 

data/lib/cw/print.rb

@@ -46,12 +46,12 @@ module CWG
 
     def reset
       @print_count = 0
-      puts "\r"
     end
 
     def newline
       reset
       update_console_size
+      puts "\r"
     end
 
     def force_newline_maybe
@@ -125,6 +125,18 @@ module CWG
       print paint("#{word}", list_colour)
     end
 
+    def tx word
+      print paint("#{word}", tx_colour)
+    end
+
+    def rx word
+      print paint("#{word}", rx_colour)
+    end
+
+    def menu word
+      print paint("#{word}", menu_colour)
+    end
+
     def success word
       newline_maybe word
       return if(@print_count == 0 && word == ' ')
@@ -143,6 +155,18 @@ module CWG
       Cfg.config["list_colour"].to_sym || :default
     end
 
+    def tx_colour
+      Cfg.config["tx_colour"].to_sym || :red
+    end
+
+    def rx_colour
+      Cfg.config["rx_colour"].to_sym || :blue
+    end
+
+    def menu_colour
+      Cfg.config["menu_colour"].to_sym || :yellow
+    end
+
     def print_advice name
       puts "#{name}: Press Q 4 times to Exit"
     end

data/lib/cw/repeat_word.rb

@@ -58,23 +58,28 @@ module CWG
       end
     end
 
+    def threads
+      threads ||= CWThreads.new(self, thread_processes)
+    end
+
     def run words
       temp_words = words.all
       temp_words.each do |word|
         loop do
+          Cfg.config.params["exit"] = false
           break if test_env
           @input_word, @words = '', Words.new
           Cfg.config.params["quit"] = false
           @words.assign word
-          @threads = CWThreads.new(self, thread_processes)
-          @threads.start_threads
-          @threads.wait_for_threads
+          threads.run
+          #          threads.start_threads
+          #          threads.wait_for_threads
           @play = nil
           system("stty -raw echo")
           break unless failed?
         end
       end
-      #      break if Cfg.config["exit"]
+      Cfg.config.params["exit"] = true
     end
   end
 end

data/lib/cw/rss.rb

@@ -1,5 +1,10 @@
 # encoding: utf-8
 
+require 'oga'
+require 'httpclient'
+require "htmlentities"
+require 'sanitize'
+
 module CWG
 
   #class Rss
@@ -22,25 +27,25 @@ module CWG
     end
 
     def read_rss(src, article_count = 3)
-      require 'feedjira'
-      require "htmlentities"
-      require 'sanitize'
+
+      Cfg.config.params["words_counted"] = true
+      @rss_articles = []
+      count = 0
       coder = HTMLEntities.new
       url   = source(src)
-      # return a Hash - each url having a Feedjira::Feed object
-      feed  = Feedjira::Feed.fetch_and_parse url
-      entry_count = 0
-      @rss_articles = []
-      feed.entries.each do |entry|
-        title = entry.title
+      content = HTTPClient.new.get_content(url)
+      document = Oga.parse_xml(content)
+      document.xpath('rss/channel/item').each do |item|
+        title = item.at_xpath('title').text
+        description = item.at_xpath('description').text
         unless(title.include?('VIDEO:') ||
                title.include?('In pictures:') ||
                title.include?('Morning business round-up'))
-          words = entry.summary
-          entry_count += 1
+          @rss_articles << Sanitize.clean(coder.decode(title)) + '. ' +
+                           Sanitize.clean(coder.decode(description))
+          count += 1
+          break if count >= article_count
         end
-        @rss_articles << (Sanitize.clean coder.decode words).split(',')
-        break if entry_count >= article_count
       end
     end
 
@@ -53,14 +58,12 @@ module CWG
     end
 
     def next_article
-      temp = @rss_articles[article_index]
-      return unless temp
+      article = @rss_articles[article_index]
+      return unless article
       inc_article_index
-      quote = ''
-      temp.map { |i| quote += i }
-      (quote.split.collect { |article| cw_chars(article.strip.delete("\"").downcase)})
+      article.split.collect do |chars|
+        cw_chars(chars.strip.delete("\"").downcase)
+      end
     end
-
   end
-
 end

data/lib/cw/tester.rb

@@ -227,6 +227,11 @@ module CWG
       exit!
     end
 
+    def cw_threads
+      @cw_threads ||= CWThreads.new(self, thread_processes)
+    end
+
+
     def thread_processes
       [
         :monitor_keys_thread,
@@ -237,8 +242,7 @@ module CWG
 
     def run words
       @words = words
-      @cw_threads = CWThreads.new(self, thread_processes)
-      @cw_threads.run
+      cw_threads.run
       @play = nil
       reset_stdin
       print.newline

data/lib/cw/tone_generator.rb

@@ -11,22 +11,48 @@ module CWG
     include ToneHelpers
     include FileDetails
 
+    attr_reader :code
+
+    class Code
+
+      include FileDetails
+
+      def initialize sample_rate, wpm
+        @sample_rate = sample_rate
+        @wpm = wpm
+        @spb_short = @sample_rate * 1.2 / @wpm
+        @spb_long = @sample_rate * 3.6 / @wpm
+      end
+
+      def filename element
+        self.send "#{element}_path"
+      end
+
+      def spb element
+        spb = element == :dash ?
+                @spb_long    :
+                @spb_short
+        spb.to_i
+      end
+    end
+
     def initialize
+      @sample_rate = 2400
       @max_amplitude = (Cfg.config["volume"].to_f > 1.0 ?
                           1.0 : Cfg.config["volume"].to_f)
       @wpm = Cfg.config["wpm"].to_f
       @frequency = Cfg.config["frequency"].to_i
       @effective_wpm = Cfg.config["effective_wpm"] ?
                          Cfg.config["effective_wpm"].to_f : @wpm
-      @sample_rate = 2400
       @print = Print.new
     end
 
-    def generate wrds
+    def code
+      @code ||= Code.new(@sample_rate, @wpm)
+    end
 
+    def generate wrds
       word_parts(wrds)
-      #    progress.init elements.size * 3 + (wrds.size)
-      create_element_methods
       compile_fundamentals
       write_word_parts
     end
@@ -35,11 +61,6 @@ module CWG
       @play_filename ||= File.join(audio_dir, audio_filename)
     end
 
-    def play
-      cmd = play_command + ' ' + play_filename
-      @pid = ! @dry_run ? Process.spawn(cmd) : cmd
-    end
-
     def cw_encoding
       @encoding ||= CwEncoding.new
     end
@@ -48,21 +69,6 @@ module CWG
       @progress ||= Progress.new('Compiling')
     end
 
-    def data
-      { :dot => {:name => :dot,
-                 :filename => dot_path,
-                 :spb => (@sample_rate * 1.2 / @wpm).to_i },
-        :dash  => {:name => :dash,
-                   :filename => dash_path,
-                   :spb => (@sample_rate * 3.6 / @wpm).to_i },
-        :space => {:name => :space,
-                   :filename   => space_path,
-                   :spb => (@sample_rate * 1.2 / @wpm).to_i },
-        :e_space => {:name => :e_space,
-                     :filename => e_space_path,
-                     :spb => (@sample_rate * 1.2 / @effective_wpm).to_i }}
-    end
-
     def filter_maybe(size, count)
       ramp = 0.05
       ramp_point =  @max_amplitude / ramp
@@ -83,11 +89,13 @@ module CWG
     end
 
     def generate_buffer audio_samples, ele
-      WaveFile::Buffer.new(audio_samples, WaveFile::Format.new(:mono, :float, data[ele][:spb]))
+      WaveFile::Buffer.new(audio_samples,
+                           WaveFile::Format.new(:mono, :float, code.spb(ele)))
     end
 
     def write_element_audio_file ele, buffer
-      WaveFile::Writer.new(data[ele][:filename], WaveFile::Format.new(:mono, :pcm_16, @sample_rate)) do |writer|
+      WaveFile::Writer.new(code.filename(ele),
+                           WaveFile::Format.new(:mono, :pcm_16, @sample_rate)) do |writer|
         writer.write(buffer)
       end
     end
@@ -96,23 +104,9 @@ module CWG
       [:dot, :dash, :space, :e_space]
     end
 
-    # create dot, dash, space or e_space method
-
-    def create_element_method ele
-      define_singleton_method(ele) {data[ele]}
-    end
-
-    # create dot, dash, space and e_space methods
-
-    def create_element_methods
-      elements.each do |ele|
-        create_element_method ele
-      end
-    end
-
     def generate_samples ele
-      return generate_space(data[ele][:spb]) if space_sample? ele
-      generate_tone(data[ele][:spb])  unless    space_sample? ele
+      return generate_space(code.spb(ele)) if space_sample? ele
+      generate_tone(code.spb(ele))     unless space_sample? ele
     end
 
     def compile_fundamentals
@@ -123,50 +117,43 @@ module CWG
       end
     end
 
+    def ewpm?
+      @effective_wpm != @wpm
+    end
+
     def space_or_espace
-      (@effective_wpm == @wpm) ? space : e_space
+      { name: (ewpm? ? :e_space : :space) }
     end
 
     def push_enc chr
       arry = []
       chr.each_with_index do |c,idx|
         arry << c
-        arry << ((last_element?(idx, chr)) ? (space_or_espace) : space)
+        arry << (last_element?(idx, chr) ? space_or_espace : { name: :space })
       end
       arry += char_space
     end
 
-    def send_char c
-      enc = nil
-      if c == ' '
-        enc = word_space
-      else
-        enc = cw_encoding.fetch(c).map { |e| send(e)}
-      end
+    def send_char(c)
+      enc = c == ' ' ? [word_space] : cw_encoding.fetch(c).map { |e|
+        { :name => e }
+      }
       push_enc enc
     end
 
-    def word_parts str = nil
+    def word_parts(str = nil)
       return @word_parts if @word_parts
       @word_parts = []
-      str.split('').each { |part| @word_parts << part}
+      str.split('').each { |part| @word_parts << part }
       @word_parts
     end
 
-    def make_word_parts
-      parts = []
-      @word_parts.each do |part|
-        parts += send_char part.downcase
-      end
-      parts
-    end
-
     def prepare_buffers
       @buffers = {}
       elements.each do |ele|
         @buffers[ele] = []
-        WaveFile::Reader.new(data[ele][:filename]).
-          each_buffer(data[ele][:spb]) do |buffer|
+        WaveFile::Reader.new(code.filename(ele))
+                        .each_buffer(code.spb(ele)) do |buffer|
           @buffers[ele] = buffer
         end
       end
@@ -178,42 +165,40 @@ module CWG
     end
 
     def char_space
-      @effective_wpm == @wpm ? [space,space] : [e_space,e_space]
+      Array.new(2, word_space)
     end
 
     def word_space
-      @effective_wpm == @wpm ? [space] : [e_space]
+      { name: (ewpm? ? :e_space : :space) }
     end
 
-    def word_composite word
+    def word_composite(word)
       send_char word.downcase
     end
 
-    def write_audio
-      WaveFile::Writer.
-        new(play_filename,
-            WaveFile::Format.
-              new(:mono,
-                  :pcm_16,
-                  @sample_rate)) do |writer|
-        yield.each do |char|
-          char.each do |fta|
-            writer.write(@buffers[fta[:name]])
-          end
-        end
-      end
+    def format
+      WaveFile::Format.new(:mono, :pcm_16, @sample_rate)
     end
 
-    def reset
-      @word_parts = @progress = nil
-      #    puts "\r"
+    def write_buffer(writer, fta)
+      writer.write(@buffers[fta[:name]])
+    end
+
+    def write_audio
+      WaveFile::Writer.new(play_filename, format) do |writer|
+        yield.map { |ch| ch.map { |fta| write_buffer(writer, fta) } }
+      end
     end
 
     def write_audio_file
       write_audio do
-        @word_parts.collect {|part| word_composite(part) }
+        @word_parts.collect { |part| word_composite(part) }
       end
       reset
     end
+
+    def reset
+      @word_parts = @progress = nil
+    end
   end
 end

data/lib/cw/tone_helpers.rb

@@ -4,7 +4,7 @@ module CWG
 
   module ToneHelpers
 
-    TWO_PI           = 2 * Math::PI
+    TWO_PI = 2 * Math::PI
 
     def convert_words wrds
       wrds.to_array.collect{ |wrd| wrd.delete("\n")}

data/lib/cw/tx.rb

@@ -0,0 +1,487 @@
+# coding: utf-8
+module CWG
+
+  class Tx < Tester
+
+    include ToneHelpers
+    include FileDetails
+
+    def initialize
+      @max_amplitude = (Cfg.config["volume"].to_f > 1.0 ?
+                          1.0 : Cfg.config["volume"].to_f)
+      @wpm = Cfg.config["wpm"].to_f
+      @frequency = Cfg.config["frequency"].to_i
+      @effective_wpm = Cfg.config["effective_wpm"] ?
+                         Cfg.config["effective_wpm"].to_f : @wpm
+      @sample_rate = 2400
+      @print = Print.new
+      @words = []
+      @recording = []
+      print.rx "\n"
+      print.tx "\n"
+      print.menu "\n"
+    end
+
+    def core_audio
+      @core_audio ||= Coreaudio.new
+    end
+
+    def add_space words
+      str = ''
+      words.to_array.collect { |word| str << word + ' '}
+      str
+    end
+
+    def monitor_keys
+      @char = '#'
+      process_letter
+
+      loop do
+        @char = key_input.read
+        break if quit_key_input?
+        break if quit?
+        break if exit?
+        check_sentence_navigation(@char) if self.class == Book
+        check_clear @char
+        process_letter
+      end
+    end
+
+    def check_clear char
+      if char == "\e"
+        @words = []
+      end
+    end
+
+    def print_mode(mode)
+      msg = "\n\r" + (mode == :rx ?
+                        "Receive Mode:" :
+                        "Transmit Mode:") + "\n\r"
+      print.tx msg if :tx == mode
+      print.rx msg if :rx == mode
+    end
+
+    def receive_mode
+      print_mode :rx
+      loop do
+        char = key_input.read
+        check_clear char
+        case char
+        when '#'
+          print_mode :tx
+          return
+        when '|'
+          capture
+        when '\\'
+          info
+        when '>'
+          return '>'
+        when "\n"
+          puts "\n"
+        when "\r"
+          puts "\r"
+        when 'Q'
+          puts "Quitting..."
+          quit!
+        else
+          if(@recording.include? ' ')
+            @recording = [char]
+          else
+            @recording << char
+          end
+          puts 'here'
+          print.rx char
+        end
+        sleep 0.001
+      end
+    end
+
+    def quit!
+      Cfg.config.params["exit"] = true
+    end
+
+    def capture
+      puts "\n\r"
+      puts "\r Menu: [C]allsign,    [N]ame, "
+      puts "\r       [L]ocation,    [R]st,  "
+      puts "\r       [T]emperature, [S]tore,"
+      puts "\r       [I]nfo,        [W]PM,  "
+      puts "\r       [Q]uit capture!"
+      puts "\r"
+      puts "\r        Use CAPITAL to capture"
+
+      loop do
+        char = key_input.read
+#        print.menu char
+        upcase = /[[:upper:]]/.match(char)
+        case char.downcase
+        when 'c'
+          return capture_attribute :callsign, upcase
+        when 'n'
+          return capture_attribute :name, upcase
+        when 'l'
+          return capture_attribute :qth, upcase
+        when 'r'
+          return capture_attribute :rst, upcase
+        when 't'
+          return capture_attribute :temperature, upcase
+        when 'i'
+          return info
+        when 's'
+          return store
+        when 'q'
+          puts "\rCancelled!"
+          return
+        else
+          puts "\nInvalid letter(#{char}) - try again!"
+        end
+        sleep 0.001
+      end
+    end
+
+    def store
+      puts "\n\r"
+      puts "\rStoring info:"
+      info
+      @their_callsign
+      @their_name
+      @their_location
+      @their_rst
+      puts "\rCleared info!"
+      puts "\r"
+    end
+
+    def capture_attribute(attr_type, use_recording = false)
+      puts "\n\r"
+      puts "Enter their #{attr_type.to_s} followed by SPACE" unless use_recording
+      temp = use_recording ? @recording : []
+      print.menu temp.join('').delete(' ') if(@recording && ! use_recording)
+      @recording = []
+      if use_recording
+        write_attribute temp, attr_type
+        return
+      end
+      loop do
+        char = key_input.read
+        if key_input.is_relevant_char?(char)
+          temp << char
+          print.menu char unless use_recording
+          if ' ' == char
+            temp << char
+            write_attribute temp, attr_type
+            return
+          end
+        elsif char == 'Q'
+          puts "\n\n\rCancelled!\n\n\r"
+          return
+        end
+      end
+    end
+
+    def write_attribute attr, type
+      clip = attr.join('').delete(' ')
+      @their_callsign = clip if :callsign == type
+      @their_name  = clip    if :name == type
+      @their_rst   = clip    if :rst == type
+      @their_qth   = clip    if :qth == type
+      @temperature = clip    if :temperature == type
+      puts "\n\n\r#{type.to_s}: #{@their_callsign.upcase}\n\n\r" if :callsign == type
+      unless :callsign == type
+        puts "\n\n\rAttr: #{@temperature}°C\n\n\r" if :temperature == type
+        puts "\n\n\rTheir #{type.to_s}: #{clip}\n\n\r" unless :temperature == type
+      end
+    end
+
+    def my_callsign
+      morsify "m0gzg "
+    end
+
+    def their_callsign
+      morsify @their_callsign unless @their_callsign.nil?
+    end
+
+    def return_with_k
+      acknowledge
+      morsify 'k '
+    end
+
+    def return_with_kn
+      morsify '+ '
+      acknowledge
+      morsify 'kn '
+    end
+
+    def acknowledge
+      their_callsign
+      morsify ' de '
+      my_callsign
+    end
+
+    def received_ok
+      acknowledge
+      morsify 'en en '
+    end
+
+    def sign_off
+      morsify "ok om #{@their_name} 73 es tnx fer nice qso = hpe 2cuagn sn + "
+      their_callsign
+      morsify ' de '
+      my_callsign
+      morsify ' sk '
+    end
+
+    def stop
+      morsify '= '
+    end
+
+    def long_cq
+      morsify "cqcq cqcq de m0gzg m0gzg k "
+    end
+
+    def morsify sentence
+      sentence.split('').collect{ |letr| char_to_tx letr }
+    end
+
+    def rst
+      morsify "rst is 599  5nn = "
+    end
+
+    def name
+      morsify "name is m a r t y n  martyn = "
+    end
+
+    def qth
+      morsify "qth is o l d  w o o d nr l i n c o l n  lincoln = "
+    end
+
+    def weather
+      morsify "hr wx is sunny with some clouds = temp #{@temperature}c = "
+    end
+
+    def dit_dit
+      morsify 'e e '
+    end
+
+    def info
+      now = Time.now.utc
+      time = now.strftime("%H:%M:%S Z")
+      date = now.strftime("%d/%m/%y")
+      puts "\r----------------------------\r"
+      puts "Time:       #{time}\r"
+      puts "Date:       #{date}\r"
+      puts "Temp:       #{@temperature}°C\r"
+      puts "\r"
+      callsign = @their_callsign.nil? ? '' : @their_callsign.upcase
+      puts "Their Call: #{callsign}\r"
+      puts "Their Name: #{@their_name}\r"
+      puts "Their RST:  #{@their_rst}\r"
+      puts "Their qth:  #{@their_qth}\r"
+      puts "\r----------------------------\r"
+      puts "\n\r"
+    end
+
+    def process_letter
+      @input_word ||= ''
+      case @char
+      when '#'
+        return_val = receive_mode
+        if '>' == return_val
+          return_with_k
+        else
+          @char = ''
+        end
+      when '.'
+        stop
+      when 'F'
+        @wpm += 1
+        @effective_wpm = @wpm
+      when 'S'
+        @wpm -= 1
+        @effective_wpm = @wpm
+      when '='
+        morsify '= '
+      when ','
+        morsify ', '
+      when '\\'
+        info
+      when '|'
+        capture
+      when '?'
+        morsify '? '
+      when '@'
+        long_cq
+      when '£'
+        my_callsign
+      when '$'
+        their_callsign
+      when '}'
+        sign_off
+      when '>'
+        return_with_k
+      when ')'
+        return_with_kn
+      when '('
+        received_ok
+      when '^'
+        qth
+      when '%'
+        rst
+      when '&'
+        name
+      when '*'
+        weather
+      when 'E'
+        dit_dit
+      when "\n"
+        puts "\n"
+      when "\r"
+        puts "\r"
+      when 'Q'
+        puts "Quitting..."
+        quit!
+      else
+        if key_input.is_relevant_char?(@char)
+          char_to_tx @char
+        end
+      end
+      @char = ''
+    end
+
+    def char_to_tx char
+      @words << char
+#      print.tx char
+    end
+
+    def thread_processes
+      [
+        :tx_words_thread,
+        :monitor_keys_thread,
+        #        :print_words_thread
+      ]
+    end
+
+    def word_composite word
+      send_char word.downcase
+    end
+
+    def push_enc chr
+      arry = []
+      chr.each_with_index do |c,idx|
+        arry << c
+        arry << ((last_element?(idx, chr)) ? (space_or_espace) : space)
+      end
+      arry += char_space
+    end
+
+    def cw_encoding
+      @encoding ||= CwEncoding.new
+    end
+
+    def space_or_espace
+      (@effective_wpm == @wpm) ? space : e_space
+    end
+
+    def char_space
+      @effective_wpm == @wpm ? [space,space] : [e_space,e_space]
+    end
+
+    def word_space
+      @effective_wpm == @wpm ? [space] : [e_space]
+    end
+
+    def send_char c
+      enc = nil
+      if c == ' '
+        enc = word_space
+      else
+        enc = cw_encoding.fetch(c).map { |e| send(e)}
+      end
+      push_enc enc
+    end
+
+    def audio_thread
+      temp = @word_parts.collect {|part| word_composite(part) }
+      @word_parts = nil
+      wpm = 1.5
+      temp.each do |letr|
+        letr.each do |ele|
+          if (:space == ele[:name]) || (:e_space == ele[:name])
+            core_audio.generate_silence(tone.data[
+                                         ele[:name]][:spb] * 20)
+          else
+            core_audio.generate_tone( tone.data[
+                                      ele[:name]][:spb] * 20)
+          end
+        end
+      end
+    end
+
+    def generate wrds
+      word_parts(wrds)
+      create_element_methods
+      core_audio.start
+      cw_threads.add self, :audio_thread
+      #      th = Thread.start do
+      cw_threads.join :audio_thread
+      sleep 0.001
+      core_audio.stop
+      cw_threads.kill_thread_x :audio_thread
+      #      puts 'end thread'
+    end
+
+    def word_parts str = nil
+      return @word_parts if @word_parts
+      @word_parts = []
+      str.split('').each { |part| @word_parts << part}
+      @word_parts
+    end
+
+    def create_element_method ele
+      define_singleton_method(ele) {tone.data[ele]}
+    end
+
+    def create_element_methods
+      elements.each do |ele|
+        create_element_method ele
+      end
+    end
+
+    def elements
+      [:dot, :dash, :space, :e_space]
+    end
+
+    def tone
+      @tone ||= ToneGenerator.new
+    end
+
+    def cw_threads
+      @cw_threads ||= CWThreads.new(self, thread_processes)
+    end
+
+    def tx string
+      @winkey = Winkey.new
+      @winkey.on
+      @winkey.echo
+      @winkey.no_weighting
+      @winkey.wpm @wpm
+#      @winkey.string "ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890/=+?>(:;"
+      @winkey.string ' fb '
+      @winkey.wait_while_sending
+      cw_threads.run
+#      @winkey.close
+    end
+
+    def tx_words_thread
+      loop do
+        unless @words == []
+          temp = @words.shift
+          #          generate temp
+#          p temp
+          @winkey.stringtemp.to_s.upcase
+          print.tx temp
+        end
+        sleep 0.01
+      end
+    end
+  end
+end