cw 0.2.4 → 0.3.0

data/lib/cw/text_helpers.rb

@@ -1,25 +1,29 @@
 # encoding: utf-8
 
-module TextHelpers
+module CWG
 
-  def letter_group
-    (97..122).to_a
-  end
+  module TextHelpers
 
-  def number_group
-    (48..57).to_a
-  end
+    def letter_group
+      (97..122).to_a
+    end
 
-  def cw_chars chr
-    chr.tr('^a-z0-9\.\,+', '')
-  end
+    def number_group
+      (48..57).to_a
+    end
+
+    def cw_chars chr
+      chr.tr('^a-z0-9\.\,+', '')
+    end
 
-  def exclude_non_cw_chars word
-    temp = ''
-    word.split.each do |chr|
-      temp += chr if letter(chr)
+    def exclude_non_cw_chars word
+      temp = ''
+      word.split.each do |chr|
+        temp += chr if letter(chr)
+      end
+      temp
     end
-    temp
+
   end
 
 end

data/lib/cw/timing.rb

@@ -1,92 +1,88 @@
 # encoding: utf-8
 
-class Timing
+module CWG
 
-  attr_accessor :delay_time
-  attr_accessor :start_time
+  class Timing
 
-  def initialize
-    @delay_time = 0.0
-    @cw_encoding = CwEncoding.new
-  end
-
-  def cw_encoding enc
-    @cw_encoding.fetch(enc)
-  end
+    attr_accessor :delay_time
+    attr_accessor :start_time
 
-  def dot wpm
-    1.2 / wpm.to_f
-  end
+    def initialize
+      @delay_time = 0.0
+      @cw_encoding = CwEncoding.new
+    end
 
-  def dot_ms
-    dot @wpm
-  end
+    def cw_encoding enc
+      @cw_encoding.fetch(enc)
+    end
 
-  def init_print_words_timeout
-    @start_print_time, @delay_print_time = Time.now, 2.0
-  end
+    def dot wpm
+      1.2 / wpm.to_f
+    end
 
-  def print_words_timeout?
-    (Time.now - @start_print_time) > @delay_print_time
-  end
+    def dot_ms
+      dot @wpm
+    end
 
-  def init_play_words_timeout
-    @start_play_time, @delay_play_time = Time.now, 2.0
-  end
+    def init_print_words_timeout
+      @start_print_time, @delay_print_time = Time.now, 2.0
+    end
 
-  def play_words_timeout?
-    (Time.now - @start_play_time) > @delay_play_time
-  end
+    def print_words_timeout?
+      (Time.now - @start_print_time) > @delay_print_time
+    end
 
-  def effective_dot_ms
-    dot @effective_wpm
-  end
+    def effective_dot_ms
+      dot @effective_wpm
+    end
 
-  def init_char_timer
-    @start_time, @delay_time = Time.now, 0.0
-  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_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}"
+    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
-    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 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 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 == ' ')
+    def char_delay(char, wpm, ewpm)
+      @wpm, @effective_wpm = wpm, ewpm
+      if(char != ' ')
+        char_timing(cw_encoding(char)) unless(char == ' ')
       else
-      space_timing
+        space_timing
+      end
+    end
+
+    def append_char_delay letr, wpm, ewpm
+      @delay_time += char_delay(letr, wpm, ewpm)
     end
-  end
 
-  def append_char_delay letr, wpm, ewpm
-    @delay_time += char_delay(letr, wpm, ewpm)
   end
 
 end

data/lib/cw/tone_generator.rb

@@ -2,200 +2,223 @@
 
 require 'wavefile'
 
-class ToneGenerator
+module CWG
 
-  include ToneHelpers
+  class ToneGenerator
 
-  def initialize
-    @max_amplitude = 0.5
-    @wpm = Params.wpm.to_f
-    @frequency = Params.frequency
-    @effective_wpm = Params.effective_wpm ? Params.effective_wpm.to_f : @wpm
-    @sample_rate = 2400
-    @print = Print.new
-  end
+    MUTE = false
 
-  def cw_encoding
-    @encoding ||= CwEncoding.new
-  end
+    include ToneHelpers
+    include FileDetails
 
-  def progress
-    @progress ||= Progress.new('Compiling')
-  end
+    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
+    end
 
-  def generate wrds
-    word_parts(wrds)
-#    progress.init elements.size * 3 + (wrds.size)
-    create_element_methods
-    compile_fundamentals
-    write_word_parts
-  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
-    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   ,
+    def play_filename
+      File.join(AUDIO,Cfg.config["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
+
+    def progress
+      @progress ||= Progress.new('Compiling')
+    end
+
+    def data
+      { :dot => {:name => :dot,
+                 :filename => DOT_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
+        :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 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 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)
-    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)
+    def generate_tone(number_of_samples)
+      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
+        #      amplitude = 0.01 if MUTE
+        sine_radians = ((@frequency * TWO_PI) / @sample_rate) * sample_number
+        audio_samples[sample_number] = amplitude * Math.sin(sine_radians)
+      end
+      audio_samples
     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 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)
+    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
-  end
 
-  def elements
-    [:dot, :dash, :space, :e_space]
-  end
+    def elements
+      [:dot, :dash, :space, :e_space]
+    end
 
-  def create_element_method ele
-    define_singleton_method(ele) {data[ele]}
-  end
+    # create dot, dash, space or e_space method
 
-  def create_element_methods
-    elements.each do |ele|
-#      progress.increment
-      create_element_method ele
+    def create_element_method ele
+      define_singleton_method(ele) {data[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
-  end
+    # create dot, dash, space and e_space methods
 
-  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
+    def create_element_methods
+      elements.each do |ele|
+        #      progress.increment
+        create_element_method ele
+      end
     end
-  end
 
-  def space_or_espace
-    (@effective_wpm == @wpm) ? space : 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 push_enc chr
-    arry = []
-    chr.each_with_index do |c,idx|
-      arry << c
-      arry << ((last_element?(idx, chr)) ? (space_or_espace) : space)
+    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
-    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)}
+    def space_or_espace
+      (@effective_wpm == @wpm) ? space : e_space
     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 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
+      enc = nil
+      if c == ' '
+        enc = word_space
+      else
+        enc = cw_encoding.fetch(c).map { |e| send(e)}
+      end
+      push_enc enc
+    end
 
-  def make_word_parts
-    parts = []
-    @word_parts.each do |part|
-#      progress.increment
-      parts += send_char part.downcase
+    def word_parts str = nil
+      return @word_parts if @word_parts
+      @word_parts = []
+      str.split('').each { |part| @word_parts << part}
+      @word_parts
     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
+
+    def make_word_parts
+      parts = []
+      @word_parts.each do |part|
+        #      progress.increment
+        parts += send_char part.downcase
       end
+      parts
     end
-  end
 
-  def write_word_parts
-    prepare_buffers
-    write_audio_file
-  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 char_space
-    @effective_wpm == @wpm ? [space,space] : [e_space,e_space]
-  end
+    def write_word_parts
+      prepare_buffers
+      write_audio_file
+    end
 
-  def word_space
-    @effective_wpm == @wpm ? [space] : [e_space]
-  end
+    def char_space
+      @effective_wpm == @wpm ? [space,space] : [e_space,e_space]
+    end
 
-  def word_composite word
-    send_char word.downcase
-  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]])
+    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
-  end
 
-  def reset
-    @word_parts = @progress = nil
-#    puts "\r"
-  end
+    def reset
+      @word_parts = @progress = nil
+      #    puts "\r"
+    end
 
-  def write_audio_file
-    write_audio { @word_parts.collect {|part| word_composite(part) } }
-    reset
+    def write_audio_file
+      write_audio do
+        @word_parts.collect {|part| word_composite(part) }
+      end
+      reset
+    end
   end
-
 end
-