stringyfi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 796dc3f1361b70dbb6c86d6f7ef77639796d12e5
+  data.tar.gz: f7ce1efbc6ead2e92c99b37f629540cc69d6f5db
+SHA512:
+  metadata.gz: 92a250942f88d6ee07ff351ce5a4fd7a2998a675f8773b1782a913cc94fc5bde540a98fcdbf2bc40b0d5d6baba3a0f1c142c4708eb776d6c3dc666f067a68c7e
+  data.tar.gz: 07ea32854390d1bcb07065ef3f5a44609399d56f1dbc04df387bd44044f66c5451ad9573c6965440b954653dfb353039f2889671a148cb744fc6a22d0f3485e4

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.ruby-gemset

@@ -0,0 +1 @@
+stringyfi

data/.ruby-version

@@ -0,0 +1 @@
+2.4.1

data/.travis.yml

@@ -0,0 +1,5 @@
+# These are specific configuration settings required for travis-ci
+# see http://travis-ci.org/tardate/stringyfi
+language: ruby
+rvm:
+  - 2.4.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in amuse.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,18 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rsspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separetly)
+#  * 'just' rspec: 'rspec'
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/stringyfi/(.+)\.rb$})     { |m| "spec/unit/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2017 Paul Gallagher
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,65 @@
+# StringyFi
+
+Convert MusicXML to PIC assembler for running on the Boldport Club Stringy.
+
+[![Build Status](https://travis-ci.org/tardate/stringyfi.svg?branch=master)](https://travis-ci.org/tardate/stringyfi)
+
+## About the Stringy
+
+The [Stringy](https://www.boldport.com/products/stringy/) is an open source hardware project
+from the wonderful [Boldport Club](http://www.boldport.club/).
+
+The Stringy was Project #14 from June 2017, and is a remix of
+[MadLab's 'Funky guitar'](http://www.madlab.org/kits/guitar.html).
+
+## About StringyFi
+
+StringyFi is a simple gem that converts MusicXML source files to
+a PIC assembler source format that can be compiled and programmed to the Stringy.
+
+See [LEAP#349 DemoBurner](https://github.com/tardate/LittleArduinoProjects/tree/master/BoldportClub/stringy/DemoBurner)
+for a complete example of this in practice.
+
+StringyFi has some serious limitations, some of which are in its implementation of MusicXML parsing,
+some are fundamental limitations of the Stringy. I have found that most scores need tweaking
+to be reproduced acceptably on the Stringy, and some are just too complex (without re-writing the Stringy firmware en-masse).
+Some key points to note:
+
+* The String uses ony 2-bit (4 levels) of note duration, so the conversion squeezes the score into 4 note durations as best as possible
+* many notation features ignored: slides, ties etc
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'stringyfi'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stringyfi
+
+## Usage
+
+The StringyFi executable accepts a file path to the MusicXML source to convert,
+and emits the assembler source on STDOUT (so it can be redirected as appropriate).
+
+For example:
+
+    $ stringyfi ./spec/fixtures/music_xml/chromatic.xml > ../CustomDemo.X/demo.tun
+
+The
+[spec/fixtures](./spec/fixtures/music_xml)
+contains a few examples that are also used in tests.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+(6. Join Boldport Club!)

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r stringyfi.rb"
+end
+

data/bin/stringyfi

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'stringyfi'
+StringyFi::Shell.new(ARGV).convert!

data/lib/stringyfi.rb

@@ -0,0 +1,5 @@
+require 'stringyfi/version'
+require 'stringyfi/shell'
+require 'stringyfi/note'
+require 'stringyfi/measures'
+require 'stringyfi/converter'

data/lib/stringyfi/converter.rb

@@ -0,0 +1,164 @@
+require 'nokogiri'
+
+class StringyFi::Converter
+
+  INITIAL_OCTAVE = 1        # setup by the stringy firmware
+  OCTAVE_OFFSET = 3         # how many octaves to offset the source
+
+  attr_accessor :filename, :xml_doc
+
+  def initialize(filename)
+    self.filename = filename
+  end
+
+  def convert!
+    $stderr.puts "converting #{filename}.."
+    shortest_fractional_duration = measures.shortest_fractional_duration
+    $stderr.puts "  shortest_fractional_duration: #{shortest_fractional_duration}"
+    $stderr.puts "  octave_range: #{measures.octave_range.inspect}"
+
+    puts score_preamble
+    puts score_body(shortest_fractional_duration)
+    puts score_coda
+
+    $stderr.puts ".. done."
+  end
+
+  def score_preamble
+    <<-EOS
+;**************************************************************************
+;** Title: #{title}
+;** Tempo: #{tempo}
+;** Encoded: #{encoding_date} with #{encoding_software}
+;** Stringyfied: #{Time.now}
+;**************************************************************************
+
+\ttstart DemoTune
+EOS
+  end
+
+  def score_coda
+    <<-EOS
+\ttrest 8
+\ttstop
+EOS
+  end
+
+  def score_body(shortest_fractional_duration)
+    lines = []
+    current_octave = INITIAL_OCTAVE + OCTAVE_OFFSET
+    measures.each_with_index do |measure, measure_index|
+      lines << "\t; measure #{measure_index+1}"
+      measure.each do |note|
+        unless note.rest?
+          if note.octave != current_octave
+            delta = note.octave - current_octave
+            sign = delta > 0 ? "+" : "-"
+            (delta.abs).times do
+              lines << "\ttoctave #{sign}1"
+            end
+            current_octave = note.octave
+          end
+        end
+        short_repeats, medium_repeats, long_repeats, very_long_repeats = note.stringy_durations(shortest_fractional_duration)
+        if note.rest?
+          (short_repeats).times     { lines << "\ttrest 1" }
+          (medium_repeats).times    { lines << "\ttrest 2" }
+          (long_repeats).times      { lines << "\ttrest 3" }
+          (very_long_repeats).times { lines << "\ttrest 4" }
+        else
+          (short_repeats).times     { lines << "\ttnote #{note.to_stringy(current_octave)},1,0  ; #{note.to_note_id}" }
+          (medium_repeats).times    { lines << "\ttnote #{note.to_stringy(current_octave)},2,0  ; #{note.to_note_id}" }
+          (long_repeats).times      { lines << "\ttnote #{note.to_stringy(current_octave)},3,0  ; #{note.to_note_id}" }
+          (very_long_repeats).times { lines << "\ttnote #{note.to_stringy(current_octave)},4,0  ; #{note.to_note_id}" }
+        end
+      end
+    end
+    lines
+  end
+
+  def title
+    xml_doc.xpath('//work/work-title').text
+  end
+
+  # Simplified - only supports one tempo for the piece
+  # assumed for quarter note
+  def tempo
+    @tempo ||= xml_doc.xpath('//measure/direction/sound/@tempo').to_s.to_i
+  end
+
+  def encoding_date
+    xml_doc.xpath('//identification/encoding/encoding-date').text
+  end
+
+  def encoding_software
+    xml_doc.xpath('//identification/encoding/software').text
+  end
+
+  def identification
+    {
+      title: title,
+      encoding: {
+        date: encoding_date,
+        software: encoding_software
+      }
+    }
+  end
+  def part_list
+    xml_doc.xpath('//part-list/score-part').each_with_object([]) do |part,memo|
+      h = {}
+      h[:id] = part.attr('id')
+      memo << h
+    end
+  end
+
+  def parts
+    xml_doc.xpath('//part')
+  end
+
+  # Returns measures for the piece.
+  # only converts one part (for now)
+  # only includes staff 1
+  def measures
+    @measures ||= begin
+      measures = StringyFi::Measures.new
+      part = parts.first
+      part.xpath('measure').each_with_index do |part_measure, m|
+        measures[m] ||= []
+        part_measure.xpath('note').each_with_object(measures[m]) do |note, memo|
+          next unless note.xpath("staff").text == "1"
+          next unless note.xpath("voice").text == "1"
+          pitch = note.xpath("pitch")
+          duration = note.xpath("duration").text.to_i
+          actual_notes = note.xpath("actual-notes").text.to_i
+          normal_notes = note.xpath("normal-notes").text.to_i
+          if actual_notes > 0 and normal_notes > 0
+            duration = duration * 1.0 * normal_notes / actual_notes
+          end
+          duration_type = note.xpath("type").text
+          memo << StringyFi::Note.new(
+            pitch.xpath('step').text,
+            pitch.xpath('octave').text,
+            pitch.xpath('alter').text,
+            duration,
+            duration_type
+          )
+        end
+      end
+      measures
+    end
+  end
+
+  def measure(measure_id)
+    measures[measure_id]
+  end
+
+  def xml_doc
+    @xml_doc ||= Nokogiri::XML(io_stream)
+  end
+
+  def io_stream
+    File.open(filename).read
+  end
+
+end

data/lib/stringyfi/measures.rb

@@ -0,0 +1,27 @@
+class StringyFi::Measures < Array
+
+  def shortest_fractional_duration
+    result = 1
+    each do |measure|
+      measure.each do |note|
+        result = note.fractional_duration if note.fractional_duration < result
+      end
+    end
+    result
+  end
+
+  def octave_range
+    lo =  hi = nil
+    each do |measure|
+      measure.each do |note|
+        next if note.rest?
+        lo ||= note.octave
+        hi ||= note.octave
+        lo = note.octave if note.octave < lo
+        hi = note.octave if note.octave > hi
+      end
+    end
+    [lo, hi]
+  end
+
+end

data/lib/stringyfi/note.rb

@@ -0,0 +1,97 @@
+class StringyFi::Note
+
+  attr_accessor :name, :octave, :alter
+  attr_accessor :tempo
+  attr_accessor :fractional_duration
+
+  def initialize(name, octave=4, alter=nil, duration=1, duration_type="quarter")
+    self.name = "#{name}".upcase
+    self.octave = "#{octave}".to_i
+    self.alter = alter.to_i rescue 0
+    self.fractional_duration = calculate_fractional_duration(duration, duration_type)
+  end
+
+  def rest?
+    name == ""
+  end
+
+  def calculate_fractional_duration(duration, duration_type)
+    divisor = {
+      "half" => 2.0,
+      "quarter" => 4.0,
+      "eighth" => 8.0,
+      "16th" => 16.0,
+      "32nd" =>  32.0
+    }[duration_type] || 1.0
+    duration/divisor
+  end
+
+  # retrun [short, medium, long, very_long] repeats for the note
+  # TODO: scale medium, long, very_long durations correctly
+  def stringy_durations(shortest_fractional_duration)
+    time_units = (fractional_duration / shortest_fractional_duration).to_i
+    case
+    when time_units >= 8
+      [0, 0, 0, 1]
+    when time_units >= 4
+      [0, 0, 1, 0]
+    when time_units >= 2
+      [0, 1, 0, 0]
+    else
+      [1, 0, 0, 0]
+    end
+  end
+
+  def to_stringy(current_octave)
+    relative_octave = octave - current_octave + 1
+    case alter
+    when 1
+      "#{name}#{relative_octave}S"
+    when -1
+      sharpy_name = {
+        'B' => 'A',
+        'E' => 'D',
+        'A' => 'G',
+        'D' => 'C',
+        'G' => 'F',
+      }[name]
+      "#{sharpy_name}#{relative_octave}S"
+    else
+      "#{name}#{relative_octave}"
+    end
+  end
+
+  # Returns the note name, regardless of octave
+  def to_note_name
+    case alter
+    when 1
+      "#{name}#"
+    when -1
+      "#{name}b"
+    else
+      name
+    end
+  end
+
+  def to_s
+    to_note_name
+  end
+
+  # Returns the note ID - unique for each frequency
+  def to_note_id
+    "#{octave}:#{name}:#{alter}"
+  end
+
+  def to_str
+    to_note_id
+  end
+
+  def inspect
+    "\"#{to_str}\""
+  end
+
+  def <=>(other)
+    self.to_note_id <=> other.to_note_id
+  end
+
+end