rintcore 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3a9b723838919efffb3f912ecefcbbbea54b9ab8
+  data.tar.gz: ce1a9e323a978ae0e7452c722aadb13f259e436b
+SHA512:
+  metadata.gz: 9fa795c99cd6f8783942d2a1fe206f5c0b4994acd0447b3e67f05984a89e6eed2e7e8e31633b0bd5be667e3634b09859086b09c8225e5dbaccf0024a821b3576
+  data.tar.gz: dfd942aa41baaf1fe91ffaff69aa3731cee4c8ae88dd697d5eae5bb4dd32339bb274ecdb438879e7d121080081ed2d9da6d929d4dc3491c03ded7b0f6f98c6ec

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p0

data/CONTRIBUTING.md

@@ -16,15 +16,19 @@ you can share.
 
 If you'd like to submit a pull request please adhere to the following:
 
-1. Your code *must* be tested. Please TDD your code!
-2. No single-character variables
-3. Two-spaces instead of tabs
-4. Single-quotes instead of double-quotes unless you are using string
+1. Your code *must* be tested. Please TDD your code! (where ever possible)
+2. do modifications on an appropriately named branch.
+3. No single-character variables
+4. Two-spaces instead of tabs
+5. Single-quotes instead of double-quotes unless you are using string
    interpolation or escapes.
-5. General Rails/Ruby naming conventions for files and classes
+6. General Rails/Ruby naming conventions for files and classes
+7. Have your commit message prefixed with the class it impacts Eg.: [PrinterDriver] Made it more awesome.
+8. A single commit can only impact one class. If your changes impact multiple classes, then
+   your pull request must have multiple commits.
 
 Plase note that you must adhere to each of the above mentioned rules.
 Failure to do so will result in an immediate closing of the pull
 request. If you update and rebase the pull request to follow the
 guidelines your pull request will be re-opened and considered for
-inclusion.
+inclusion.

data/README.md

@@ -1,10 +1,30 @@
-# Hornet
+# RintCore
+
+[![Code Climate](https://codeclimate.com/github/KazW/RintCore.png)](https://codeclimate.com/github/KazW/RintCore)
 
 A RepRap/GCode parsing and sending utility written in Ruby.
 
-### TODO
+### Usage
+Install: ```gem install rintcore```
+
+Get stats for a GCode file: ```rintcore analyze my_print.gcode```
+Print a GCode file: ```rintcore print my_print.gcode```
+See more options: ```rintcore help```
+
+Use it somewhere else:
+```ruby
+require 'rint_core/printer'
+require 'rint_core/g_code/object'
+gcode = RintCore::GCode::Object.new('my_print.gcode')
+printer = RintCore::Printer.new
+printer.port = '/dev/ttyUSB0' # Set to /dev/ttyACM0 by default
+printer.baud = 250000 # Set to 115200 by default
+printer.callbacks[:temperature] = Proc.new { |line| puts(line) }
+printer.connect!
+printer.start_print gcode```
 
-Update this list and everything else in general.
+### TODO
+Documentation and spec writing.
 
 ### Contributing
 See CONTRIBUTING.md
@@ -13,7 +33,7 @@ See CONTRIBUTING.md
 
 Copyright (C) 2013  Kaz Walker
 
-The PrinterDriver class is based on printcore.py by Kliment Yanev and various contributors.
+The Driver modules are based on printcore.py by Kliment Yanev and various contributors.
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as

data/bin/rintcore

@@ -0,0 +1,5 @@
+#!env ruby
+require 'rubygems'
+require 'rint_core/cli'
+
+RintCore::Cli.start

data/lib/rint_core/cli.rb

@@ -0,0 +1,87 @@
+require 'rint_core/g_code/object'
+require 'rint_core/printer'
+require 'rint_core/g_code/codes'
+require 'thor'
+require 'active_support/core_ext/object/blank'
+
+module RintCore
+  class Cli < Thor
+    map '-a' => :analyze, '-p' => :print
+
+    desc 'analyze FILE', 'Get statistics about the given GCode file.'
+    method_option :decimals, default: 2, aliases: '-d', type: :numeric, desc: 'The number of decimal places given for measurements.'
+    def analyze(file)
+      unless RintCore::GCode::Object.is_file?(file)
+        puts "Non-exsitant file: #{file}"
+        exit
+      end
+      @object = RintCore::GCode::Object.new(RintCore::GCode::Object.get_file(file))
+      decimals = options[:decimals]
+      decimals ||= 2
+      output = <<EOS
+Dimensions:
+\tX: #{@object.x_min.round(decimals)} - #{@object.x_max.round(decimals)} (#{@object.width.round(decimals)}mm)
+\tY: #{@object.y_min.round(decimals)} - #{@object.y_max.round(decimals)} (#{@object.depth.round(decimals)}mm)
+\tZ: #{@object.z_min.round(decimals)} - #{@object.z_max.round(decimals)} (#{@object.height.round(decimals)}mm)
+Total Travel:
+\tX: #{@object.x_travel.round(decimals)}mm
+\tY: #{@object.y_travel.round(decimals)}mm
+\tZ: #{@object.z_travel.round(decimals)}mm
+Filament used: #{@object.filament_used.round(decimals)}mm
+Number of layers: #{@object.layers}
+#{@object.raw_data.length} lines / #{@object.lines.length} commands
+EOS
+      puts output
+    end
+    
+    desc 'print FILE', 'Print the given GCode file.'
+    method_option :port, aliases: '-p', type: :string, desc: 'The port that the printer is connected to.'
+    method_option :baud, aliases: '-b', type: :numeric, desc: 'The baud rate at which the printer communicates at.'
+    method_option :loud, aliases: '-l', default: false, type: :boolean, desc: 'Output additional info (temperature, progress, etc.)'
+    def print(file)
+      analyze(file)
+      port = options[:port]
+      baud = options[:baud]
+      baud = baud.to_i unless baud.blank?
+      baud = nil unless RintCore::Printer.baud_rates.include?(baud)
+      port = nil unless RintCore::Printer.is_port?(port)
+      while port.blank?
+        puts "Please enter the port and press enter:"
+        port = $stdin.gets.strip
+        port = nil unless RintCore::Printer.is_port?(port)
+      end
+      while baud.blank?
+        puts "Please enter the baud rate and press enter:"
+        baud = $stdin.gets.strip
+        baud = baud.to_i unless baud.blank?
+        baud = nil unless RintCore::Printer.baud_rates.include?(baud)
+      end
+      printer = RintCore::Printer.new
+      printer.port = port
+      printer.baud = baud
+      printer.callbacks[:online] = Proc.new { puts "Printer online!" }
+      printer.callbacks[:start] = Proc.new { puts "Started printing!" }
+      printer.callbacks[:finish] = Proc.new { puts "Print took: "+printer.time_from_start }
+      printer.callbacks[:temperature] = Proc.new { |line| puts line }
+      if options[:loud]
+        printer.callbacks[:receive] = Proc.new { |line| puts "Got: "+line }
+        printer.callbacks[:send] = Proc.new { |line| puts "Sent: "+line }
+      end
+      printer.callbacks[:disconnect] = Proc.new { puts "Printer disconnected!" }
+      printer.connect!
+      until printer.online?
+        sleep(printer.long_sleep)
+      end
+      start_time = Time.now
+      printer.start_print(@object)
+      while printer.printing?
+        printer.send_now(RintCore::GCode::Codes::GET_EXT_TEMP)
+        sleep 4.20
+        puts "Printed "+((Float(printer.queue_index) / Float(printer.main_queue.length))*100).round(2).to_s+"% in "+printer.time_from_start
+        sleep 1
+      end
+      printer.disconnect!
+    end
+
+  end
+end

data/lib/rint_core/driver.rb

@@ -0,0 +1,22 @@
+require 'rint_core/driver/operating_system'
+require 'rint_core/driver/state'
+require 'rint_core/driver/parsing'
+require 'rint_core/driver/queueing'
+require 'rint_core/driver/operations'
+
+module RintCore
+  module Driver
+    include RintCore::Driver::OperatingSystem
+    include RintCore::Driver::State
+    include RintCore::Driver::Parsing
+    include RintCore::Driver::Queueing
+    include RintCore::Driver::Operations
+    
+    def initialize_driver
+      initialize_state
+      initialize_queueing
+      initialize_operations
+    end
+
+  end
+end

data/lib/rint_core/driver/operating_system.rb

@@ -0,0 +1,30 @@
+module RintCore
+  module Driver
+    module OperatingSystem
+      def control_ttyhup(port, disable_hup)
+        if get_os == :linux
+          if disable_hup
+            `stty -F #{port} -hup`
+          else
+            `stty -F #{port} hup`
+          end
+        end
+      end
+
+      def enable_hup(port)
+        control_ttyhup(port, true)
+      end
+
+      def disable_hup(port)
+        control_ttyhup(port, false)
+      end
+
+      def get_os
+        return :linux if /linux/ =~ RUBY_PLATFORM
+        return :mac if /darwin/ =~ RUBY_PLATFORM
+        return :windows if /cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM
+        return :unknown
+      end
+    end
+  end
+end

data/lib/rint_core/driver/operations.rb

@@ -0,0 +1,209 @@
+require 'rint_core/g_code/codes'
+require 'rint_core/g_code/object'
+require 'serialport'
+require 'active_support/core_ext/object/blank'
+
+module RintCore
+  module Driver
+    module Operations
+
+      def connect!
+        return false if connected?
+        if config.port.present? && config.baud.present?
+          disable_hup(config.port)
+          @connection = SerialPort.new(config.port, config.baud)
+          @connection.read_timeout = config.read_timeout
+          @stop_listening = false
+          sleep(config.long_sleep)
+          @listening_thread = Thread.new{listen()}
+          config.callbacks[:connect].call if config.callbacks[:connect].present?
+        end
+      end
+
+      def disconnect!
+        if connected? 
+          if @listening_thread
+            @stop_listening = true
+            send!(RintCore::GCode::Codes::GET_EXT_TEMP)
+            @listening_thread.join
+            @listening_thread = nil
+          end
+          @connection.close
+        end
+        @connection = nil
+        offline!
+        not_printing!
+        config.callbacks[:disconnect].call if config.callbacks[:disconnect].present?
+      end
+
+      def reset!
+        @connection.dtr = 0
+        sleep(config.long_sleep)
+        @connection.dtr = 1
+      end
+
+      def pause!
+        return false unless printing?
+        @paused = true
+        not_printing!
+        @print_thread.join
+        @print_thread = nil
+        config.callbacks[:pause].call if config.callbacks[:pause].present?
+      end
+
+      def resume!
+        return false unless paused?
+        paused!
+        printing!
+        @print_thread = Thread.new{print!()}
+        config.callbacks[:resume].call if config.callbacks[:resume].present?
+      end
+
+      def send(command, wait = 0, priority = false)
+        if online?
+          if printing?
+            priority ? @priority_queue.push(command) : @main_queue.push(command)
+          else
+            until clear_to_send? do
+              sleep(config.sleep_time)
+            end
+            wait = config.wait_period if wait == 0 && config.wait_period > 0
+            not_clear_to_send!
+            send!(command)
+            while wait > 0 && !clear_to_send? do
+              sleep config.sleep_time
+              wait -= 1
+            end
+          end
+        else
+          # TODO: log something about not being connected to printer
+        end
+      end
+
+      def send_now(command, wait = 0)
+        send(command, wait, true)
+      end
+
+      def start_print(data, start_index = 0)
+        return false unless can_print?
+        data = data.lines if data.class == RintCore::GCode::Object
+        printing!
+        @main_queue = [] + data
+        @line_number = 0
+        @queue_index = start_index
+        @resend_from = -1
+        send!(RintCore::GCode::Codes::SET_LINE_NUM, -1, true)
+        return true unless data.present?
+        @print_thread = Thread.new{print!()}
+        @start_time = Time.now
+        return true
+      end
+
+private
+
+      def initialize_operations
+        @connection = nil
+        @listening_thread = nil
+        @printing_thread = nil
+        @full_history = []
+      end
+
+      def readline!
+        begin
+          line = @connection.readline.strip
+        rescue EOFError, Errno::ENODEV => e
+          config.callbacks[:critcal_error].call(e) if config.callbacks[:critcal_error].present?
+        end
+      end
+
+      def print!
+        @machine_history = []
+        config.callbacks[:start].call if config.callbacks[:start].present?
+        while online? && printing? do
+          advance_queue
+        end
+        @print_thread.join
+        @print_thread = nil
+        config.callbacks[:finish].call if config.callbacks[:finish].present?
+        return true
+      end
+
+      def listen
+        clear_to_send!
+        listen_until_online
+        while listen_can_continue? do
+          line = readline!
+          @last_line_received = line
+          case get_response_type(line)
+          when :valid
+            config.callbacks[:receive].call(line) if config.callbacks[:receive].present?
+            clear_to_send!
+          when :online
+            config.callbacks[:receive].call(line) if config.callbacks[:receive].present?
+          when :temperature
+            config.callbacks[:temperature].call(line) if config.callbacks[:temperature].present?
+          when :temperature_response
+            config.callbacks[:temperature].call(line) if config.callbacks[:temperature].present?
+            clear_to_send!
+          when :error
+            config.callbacks[:printer_error] if config.callbacks[:printer_error].present?
+            # TODO: Figure out if an error should be raised here or if it should be left to the callback
+          when :resend
+            @resend_from = get_resend_number(line)
+            config.callbacks[:resend] if config.callbacks[:resend].present?
+            clear_to_send!
+          when :debug
+            config.callbacks[:debug] if config.callbacks[:debug].present?
+          when :invalid
+            config.callbacks[:invalid_response] if config.callbacks[:invalid_response].present?
+            #break
+          end
+          # clear_to_send!
+        end
+        #clear_to_send!
+      end
+
+      def listen_until_online
+        begin
+          empty_lines = 0
+          accepted_reponses = [:online,:temperature,:valid]
+          while listen_can_continue? do
+            line = readline!
+            if line.present?
+              empty_lines = 0 
+            else 
+              empty_lines += 1
+              not_clear_to_send!
+              send!(RintCore::GCode::Codes::GET_EXT_TEMP)
+            end
+            break if empty_lines == 5
+            if accepted_reponses.include?(get_response_type(line))
+              config.callbacks[:online].call if config.callbacks[:online].present?
+              online!
+              return true
+            end
+            sleep(config.long_sleep)
+          end
+          raise "Printer could not be brought online."
+        rescue RuntimeError => e
+          config.callbacks[:critcal_error].call(e) if config.callbacks[:critcal_error].present?
+        end
+      end
+
+      def send!(command, line_number = 0, calc_checksum = false)
+        if calc_checksum
+          command = prefix_command(command, line_number)
+          @machine_history[line_number] = command unless command.include?(RintCore::GCode::Codes::SET_LINE_NUM)
+        end
+        if connected?
+          config.callbacks[:send].call(command) if online? && config.callbacks[:send].present?
+          command = format_command(command)
+          @connection.write(command)
+          @full_history << command
+        end
+      end
+
+
+    end
+  end
+end

data/lib/rint_core/driver/parsing.rb

@@ -0,0 +1,39 @@
+require 'rint_core/g_code/codes'
+require 'active_support/core_ext/object/blank'
+
+module RintCore
+  module Driver
+    module Parsing
+
+      def format_command(command)
+        (command.strip + "\n").split(RintCore::GCode::Codes::COMMENT_SYMBOL).first.encode(config.encoding)
+      end
+
+      def get_checksum(command)
+        command.bytes.inject{|a,b| a^b}.to_s
+      end
+
+      def prefix_command(command, line_number)
+        prefix = ('N' + line_number.to_s + ' ' + command.strip).encode(config.encoding)
+        prefix+'*'+get_checksum(prefix)
+      end
+
+      def get_response_type(line)
+        return :invalid unless line.present? || line.class == String
+        return :error if line.include?(config.error_response)
+        return :debug if line.include?(config.debug_response)
+        return :online if line.start_with?(*config.online_response)
+        return :valid if line.start_with?(*config.good_response) && !line.include?(config.temperature_response)
+        return :temperature_response if line.start_with?(*config.good_response) && line.include?(config.temperature_response)
+        return :temperature if line.include?(config.temperature_response)
+        return :resend if line.start_with?(*config.resend_response)
+        return :invalid
+      end
+
+      def get_resend_number(line)
+        line.sub('N:', '').sub('N', '').sub(':', '').strip.split.first.to_i
+      end
+
+    end
+  end
+end