cw 0.0.1

data/lib/cw/test_letters.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+class TestLetters < FileDetails
+
+  include Tester
+
+  def initialize
+    @print_letters = Params.print_letters
+    super()
+#    print_test_advice
+  end
+
+  def print_test_advice    ; print.print_advice('Test Letters')  ; end
+
+  def print_words words
+    timing.init_char_timer
+    (words.to_s + space).each_char do |letr|
+      process_letter letr
+      stream.add_char letr
+      loop do
+        process_word_maybe
+        break if timing.char_delay_timeout?
+      end
+      print.prn letr if print_letters?
+      break if quit?
+    end
+  end
+
+  def process_input_word_maybe
+    if @word_to_process
+      stream.match_first_active_element @process_input_word # .strip
+      @process_input_word = @word_to_process = nil
+    end
+  end
+
+  def build_word_maybe
+    @input_word ||= empty_string
+    @input_word << key_chr if is_relevant_char?
+    move_word_to_process if is_relevant_char?
+  end
+
+  def process_letter letr
+    letr.downcase!
+    sleep_char_delay letr
+  end
+
+  def print_marked_maybe
+    @popped = stream.pop_next_marked
+    print.char_result(@popped) if(@popped && ! print_letters?)
+  end
+
+end

data/lib/cw/test_words.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+class TestWords < FileDetails
+
+  include Tester
+
+  def initialize
+    @print_letters = Params.print_letters
+
+    super()
+
+#    print_test_advice
+  end
+
+  def print_test_advice    ; print.print_advice('Test Words')    ; end
+
+  def print_failed_exit_words
+    until stream.stream_empty?
+      print.prn_red stream.pop[:value] + ' '
+    end
+  end
+
+  def print_words words
+    timing.init_char_timer
+    (words.to_s + space).each_char do |letr|
+      process_letter letr
+      loop do
+        process_space_maybe letr
+        process_word_maybe
+        break if timing.char_delay_timeout?
+      end
+      print.prn letr if print_letters?
+      break if quit?
+    end
+  end
+
+  def process_input_word_maybe
+    if @word_to_process
+      stream.match_last_active_element @process_input_word.strip
+      @process_input_word = @word_to_process = nil
+    end
+  end
+
+  def build_word_maybe
+    @input_word ||= empty_string
+    @input_word << key_chr if is_relevant_char?
+    move_word_to_process if complete_word?
+  end
+
+  def process_letter letr
+    current_word.process_letter letr
+    sleep_char_delay letr
+  end
+
+  def print_marked_maybe
+    @popped = stream.pop_next_marked
+    print.results(@popped) if(@popped && ! print_letters?)
+  end
+end

data/lib/cw/tester.rb

@@ -0,0 +1,221 @@
+# encoding: utf-8
+
+module Tester
+
+  def quit?                ; @quit                             ; end
+  def quit                 ; @quit = true                      ; end
+  def global_quit?         ; @global_quit                      ; end
+  def global_quit          ; @global_quit = true               ; end
+  def print                ; @print ||= Print.new              ; end
+  def timing               ; @timing ||= Timing.new            ; end
+  def audio                ; @audio ||= AudioPlayer.new        ; end
+  def kill_threads         ; @threads.kill                     ; end
+  def space                ; ' '                               ; end
+  def empty_string         ; ''                                ; end
+  def spawn_play(cmd)      ; Process.spawn(cmd)                ; end
+  def start_sync           ; @start_sync = true                ; end
+  def get_key_input        ; key_input.read                    ; end
+  def key_chr              ; key_input.char                    ; end
+  def key_input            ; @key_input ||= KeyInput.new       ; end
+  def is_relevant_char?    ; key_input.is_relevant_char?       ; end
+  def quit_key_input?      ; key_input.quit_input?             ; end
+  def stream               ; @stream ||= Stream.new            ; end
+  def reset_stdin          ; key_input.reset_stdin             ; end
+  def current_word         ; @current_word ||= CurrentWord.new ; end
+  def init_char_timer      ; timing.init_char_timer            ; end
+  def audio_still_playing? ; audio.still_playing?              ; end
+
+  def add_space words
+    str = ''
+    words.to_array.collect { |word| str << word + space}
+    str
+  end
+
+  def audio_play
+    audio.convert_words add_space @words
+    start_sync
+    audio.play
+  end
+
+  def play_words_until_quit
+    audio_play
+    play_words_exit unless @print_letters
+  end
+
+  def play_words_exit
+    timing.init_play_words_timeout
+    loop do
+      break if quit?
+      break if timing.play_words_timeout?
+      sleep 0.01
+    end
+  end
+
+  def process_word_maybe
+    print_marked_maybe
+    process_input_word_maybe
+  end
+
+  def play_words_thread
+    play_words_until_quit
+    print "\n\rplay has quit " if @debug
+  end
+
+  def print_words_thread
+    print_words_until_quit
+    kill_threads
+    print "\n\rprint has quit " if @debug
+  end
+
+  def print_words_until_quit
+    sync_with_audio_player
+    print_words @words
+    print_words_exit unless @print_letters
+    quit
+  end
+
+  def print_failed_exit_words
+    until stream.stream_empty?
+      print.prn_red stream.pop[:value]
+    end
+  end
+
+  def print_words_exit
+    timing.init_print_words_timeout
+    loop do
+      process_word_maybe
+      break if stream.stream_empty?
+      break if timing.print_words_timeout?
+      break if quit?
+      sleep 0.01
+    end
+    @failed = true unless stream.stream_empty?
+    print_failed_exit_words unless @repeat_word
+  end
+
+  def audio_stop
+    audio.stop if audio_still_playing?
+  end
+
+  def wait_player_startup_delay
+    audio.startup_delay
+  end
+
+  def sync_with_audio_player
+    wait_for_start_sync
+    wait_player_startup_delay
+  end
+
+  def check_quit_key_input
+    if quit_key_input?
+      quit
+      global_quit
+      audio_stop
+    end
+  end
+
+  def push_letter_to_current_word letr
+    current_word.push_letter letr
+  end
+
+  def get_word_last_char
+    @input_word.split(//).last(1).first
+  end
+
+  def wait_for_no_word_process
+    while @word_to_process
+      sleep 0.1
+    end
+  end
+
+  def complete_word?
+    get_word_last_char == space
+  end
+
+  def move_word_to_process
+    wait_for_no_word_process
+    @process_input_word, @input_word = @input_word, ''
+    @word_to_process = true
+  end
+
+  def start_sync?
+    if @start_sync
+      @start_sync = nil
+      true
+    else
+      nil
+    end
+  end
+
+  def sleep_char_delay letr
+    timing.append_char_delay letr, Params.wpm, Params.effective_wpm
+  end
+
+  def wait_for_start_sync
+    until start_sync?
+      sleep 0.001
+      break if quit?
+    end
+  end
+
+  def process_space_maybe letr
+    if letr == space
+      stream.add_word current_word.strip
+      current_word.clear
+      letr.clear
+      print.prn space if print_letters?
+    end
+  end
+
+  def print_letters?
+    @print_letters && ! quit?
+  end
+
+  def sync_with_play
+    loop do
+      break if sentence_index_current?
+      break if quit?
+      sleep 0.015
+    end
+  end
+
+  def sync_with_print
+    loop do
+      make_sentence_index_current if ! sentence_index_current?
+      break if sentence_index_current?
+      break if quit?
+      sleep 0.015
+    end
+  end
+
+  def monitor_keys_thread
+    monitor_keys
+    print "\n\rmonitor keys has quit " if @debug
+  end
+
+  def thread_processes
+    [:monitor_keys_thread,
+     :play_words_thread,
+     :print_words_thread]
+  end
+
+  def run words
+    @words = words
+    words.double_words if Params.double_words
+    @threads = CWThreads.new(self, thread_processes)
+    @threads.run
+    reset_stdin
+    print.newline
+  end
+
+  def monitor_keys
+    loop do
+      get_key_input
+      check_quit_key_input
+      break if quit?
+      #      check_sentence_navigation key_chr
+      build_word_maybe
+    end
+  end
+
+end

data/lib/cw/timing.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+class Timing
+
+  attr_accessor :delay_time
+  attr_accessor :start_time
+
+  def initialize
+    @delay_time = 0.0
+    @cw_encoding = CwEncoding.new
+  end
+
+  def cw_encoding enc
+    @cw_encoding.fetch(enc)
+  end
+
+  def dot wpm
+    1.2 / wpm
+  end
+
+  def dot_ms
+    dot @wpm
+  end
+
+  def init_print_words_timeout
+    @start_print_time, @delay_print_time = Time.now, 2.0
+  end
+
+  def print_words_timeout?
+    (Time.now - @start_print_time) > @delay_print_time
+  end
+
+  def init_play_words_timeout
+    @start_play_time, @delay_play_time = Time.now, 2.0
+  end
+
+  def play_words_timeout?
+    (Time.now - @start_play_time) > @delay_play_time
+  end
+
+  def effective_dot_ms
+    dot @effective_wpm
+  end
+
+  def init_char_timer
+    @start_time, @delay_time = Time.now, 0.0
+  end
+
+  def char_delay_timeout?
+    (Time.now - @start_time) > @delay_time
+  end
+
+  def char_timing(* args)
+    timing = 0
+    args.flatten.each do |arg|
+      case arg
+      when :dot  then timing += 2
+      when :dash then timing += 4
+      else
+        puts "Error! invalid morse symbol - was #{arg}"
+      end
+    end
+    timing -= 1
+    timing = timing.to_f * dot_ms
+    timing + code_space_timing
+  end
+
+  def code_space_timing
+    @effective_wpm ? 3.0 * effective_dot_ms :
+      3.0 * dot_ms
+  end
+
+  def space_timing
+    space = 4.0
+    @effective_wpm ? space * effective_dot_ms :
+      space * dot_ms
+  end
+
+  def char_delay(char, wpm, ewpm)
+    @wpm, @effective_wpm = wpm, ewpm
+    if(char != ' ')
+      char_timing(cw_encoding(char)) unless(char == ' ')
+      else
+      space_timing
+    end
+  end
+
+  def append_char_delay letr, wpm, ewpm
+    @delay_time += char_delay(letr, wpm, ewpm)
+  end
+
+end

data/lib/cw/tone_generator.rb

@@ -0,0 +1,225 @@
+# encoding: utf-8
+
+require 'wavefile'
+
+class ToneGenerator
+
+  DOT_FILENAME     = "audio/dot.wav"
+  DASH_FILENAME    = "audio/dash.wav"
+  SPACE_FILENAME   = "audio/space.wav"
+  E_SPACE_FILENAME = "audio/e_space.wav"
+  TWO_PI           = 2 * Math::PI
+
+  def initialize
+    @max_amplitude = 0.5
+    @wpm = Params.wpm
+    @frequency = Params.frequency
+    @effective_wpm = Params.effective_wpm ? Params.effective_wpm : @wpm
+    @sample_rate = 2400
+    @print = Print.new
+  end
+
+  def cw_encoding
+    @encoding ||= CwEncoding.new
+  end
+
+  def convert_words wrds
+    wrds.to_array.collect{ |wrd| wrd.gsub("\n","")}
+  end
+
+  def progress
+    @progress ||= Progress.new('Compiling')
+  end
+
+  def generate wrds
+    word_parts(wrds)
+#    progress.init elements.size * 3 + (wrds.size)
+    create_element_methods
+    compile_fundamentals
+    write_word_parts
+  end
+
+  def play_filename
+    "audio/#{Params.audio_filename}"
+  end
+
+  def play
+    cmd = play_command + ' ' + play_filename
+    @pid = ! @dry_run ? Process.spawn(cmd) : cmd
+  end
+  def data
+    { :dot => {:name => :dot,
+               :filename => DOT_FILENAME,
+               :spb => (@sample_rate * 1.2 / @wpm).to_i },
+      :dash  => {:name => :dash,
+                 :filename => DASH_FILENAME,
+                 :spb => (@sample_rate * 3.6 / @wpm).to_i },
+      :space => {:name => :space,
+                 :filename   => SPACE_FILENAME   ,
+                 :spb => (@sample_rate * 1.2 / @wpm).to_i },
+      :e_space => {:name => :e_space,
+                   :filename => E_SPACE_FILENAME ,
+                   :spb => (@sample_rate * 1.2 / @effective_wpm).to_i }}
+  end
+
+  def generate_space number_of_samples
+    [].fill(0.0, 0, number_of_samples)
+  end
+
+  def filter_maybe(size, count)
+    ramp = 0.05
+    ramp_point =  @max_amplitude / ramp
+    ampl = (count < ramp_point) ? (ramp * count) : @max_amplitude
+    (count > (size - ramp_point)) ? (ramp * (size - count)) : ampl
+  end
+
+  def generate_tone(number_of_samples)
+    position_in_period, position_in_period_delta =  0.0, @frequency / @sample_rate
+    audio_samples = [].fill(0.0, 0, number_of_samples)
+    number_of_samples.times do |sample_number|
+      amplitude = filter_maybe(number_of_samples, sample_number)
+      #      amplitude = 1.0 # @max_amplitude
+      sine_radians = ((@frequency * TWO_PI) / @sample_rate) * sample_number
+      audio_samples[sample_number] = amplitude * Math.sin(sine_radians)
+    end
+    audio_samples
+  end
+
+  def generate_buffer audio_samples, ele
+    WaveFile::Buffer.new(audio_samples, WaveFile::Format.new(:mono, :float, data[ele][:spb]))
+  end
+
+  def write_element_audio_file ele, buffer
+    WaveFile::Writer.new(data[ele][:filename], WaveFile::Format.new(:mono, :pcm_16, @sample_rate)) do |writer|
+      writer.write(buffer)
+    end
+  end
+
+  def elements
+    [:dot, :dash, :space, :e_space]
+  end
+
+  def create_element_method ele
+    define_singleton_method(ele) {data[ele]}
+  end
+
+  def create_element_methods
+    elements.each do |ele|
+#      progress.increment
+      create_element_method ele
+    end
+  end
+
+  def space_sample? ele
+    ele == :space || ele == :e_space
+  end
+
+  def generate_samples ele
+    return generate_space(data[ele][:spb]) if space_sample? ele
+    generate_tone(data[ele][:spb])  unless    space_sample? ele
+  end
+
+  def compile_fundamentals
+    elements.each do |ele|
+#      progress.increment
+      audio_samples = generate_samples ele
+      buffer = generate_buffer(audio_samples, ele)
+      write_element_audio_file ele, buffer
+    end
+  end
+
+  def space_or_espace
+    (@effective_wpm == @wpm) ? space : e_space
+  end
+
+  def last_element? idx, chr
+    idx == chr.size - 1
+  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 send_char c
+    if c == ' '
+      enc = word_space
+    else
+      enc = cw_encoding.fetch(c).map { |enc| send(enc)}
+    end
+    push_enc enc
+  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 make_word_parts words
+    parts = []
+    @word_parts.each do |part|
+#      progress.increment
+      parts += send_char part.downcase
+    end
+    parts
+  end
+
+  def prepare_buffers
+    @buffers = {}
+    elements.each do |ele|
+#      progress.increment
+      @buffers[ele] = []
+      WaveFile::Reader.new(data[ele][:filename]).
+        each_buffer(data[ele][:spb]) do |buffer|
+        @buffers[ele] = buffer
+      end
+    end
+  end
+
+  def write_word_parts
+    prepare_buffers
+    write_audio_file
+  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 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|
+#        progress.increment
+        char.each do |fta|
+          writer.write(@buffers[fta[:name]])
+        end
+      end
+    end
+  end
+
+  def reset
+    @word_parts = @progress = nil
+#    puts "\r"
+  end
+
+  def write_audio_file
+    write_audio { @word_parts.collect {|part| word_composite(part) } }
+    reset
+  end
+
+end
+