rotor 0.1.2 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 055300c3ef4b8bee15608cdd8db5346ef80ca1be
-  data.tar.gz: f83b5630dbff6e8b5913c8d4ff5adc4d7f5b1efe
+  metadata.gz: 4e48e610c2097d68d9a98bbf70151730a9957875
+  data.tar.gz: be5914357afb26ab29806eb649f1f00196fa8267
 SHA512:
-  metadata.gz: db3770db1d43f03fc0026addb7c0642b5e962bce74fb95dc08517bec68e36e1ad28a83a1f6468b74178d53c7dc8e4e689c7b397756a3f6dab3e538f29a56aa85
-  data.tar.gz: 2620dbb8c796e25ab0a155a1e74d42c6ab49f873e588a12adadf4ef823b15fe1b28ebc8bf49a01c6fc9ddcbedfb111d10fb2db7f212ddeae0c57706b19478ad9
+  metadata.gz: c35be0d4fbde64f072d1405913058437be150c37842f42afbd24a50df9f4258089d23c9801d6d877cfa1c95e02a375db2f2feaa67da2716a5f889910ba9a69e5
+  data.tar.gz: e00420f6330260ee0bf2f5ec49e0e84d60fc8ea78457610ae0cc7536f38bab87e087a12982822ea5b2532d9f3928879937df20b2658980d4d94351e4a8ce9916

data/.gitignore

@@ -12,4 +12,5 @@
 *.o
 *.a
 mkmf.log
-*.gem
+*.gem
+.DS_Store

data/README.md

@@ -1,220 +1,285 @@
-# Rotor (Ruby Motor)
+Rotor (Ruby Motor)
+==================
 
 Tested on RaspberryPi Model B+ but should work for any Raspberry Pi.
 
-This Ruby gem allows you to control different kinds of stepper motors. You
-can use this gem to run both Bipolar and Unipolar motors with either L293D
-or ULN2800 Integrated Controllers.
+This Ruby gem allows you to control different kinds of stepper motors. You can
+use this gem to run both Bipolar and Unipolar motors with either L293D or
+ULN2800 Integrated Controllers.
 
-## Installation
+Installation
+------------
 
-  Make sure that you have WiringPi installed first
+### WiringPi
 
-    gem install wiringpi
+Make sure that you have WiringPi installed first
 
-  If you are using GPIO Pins from a A+/B+, you may need to update your
-  WiringPi libraries. You can pull from my repo https://github.com/kobaltz/WiringPi-Ruby
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+gem install wiringpi
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-  I did not write any of the WiringPi-Ruby platform. I simply pulled the latest C libraries
-  and recompiled the gem. 
+If you are using GPIO Pins from a A+/B+, you may need to update your WiringPi
+libraries. You can pull from my repo
+[https://github.com/kobaltz/WiringPi-Ruby][1]
 
-  Install Rotor
+[1]: <https://github.com/kobaltz/WiringPi-Ruby >
 
-    gem install rotor
+I did not write any of the WiringPi-Ruby platform. I simply pulled the latest C
+libraries and recompiled the gem.
 
-# Notes
+### Rotor
 
-  This gem has been built for my personal project. I do not and cannot know if this will
-  work with your setup. However, put in an issue if you're having troubles with this gem
-  and I will try to help you as best as I can.
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+gem install rotor
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-  I am using two stepper motors (NEMA17 Bipolar 20Ncm 12V) and two L293D motor drivers. This
-  gem has also been tested with a small 5V Unipolar Stepper Motor and 12V Unipolar Stepper Motor.
+Notes
+=====
 
-  My Steps Per MM is based on a 200 step per revolution motor and a threaded rod with 20 threads per inch.
-  This means that I will have to step 4000 times to move the coupler one inch.
+This gem has been built for my personal project. I do not and cannot know if
+this will work with your setup. However, put in an issue if you're having
+troubles with this gem and I will try to help you as best as I can.
 
-# Usage
+I am using two stepper motors (NEMA17 Bipolar 20Ncm 12V) and two L293D motor
+drivers. This gem has also been tested with a small 5V Unipolar Stepper Motor
+and 12V Unipolar Stepper Motor.
 
-  ## Class Stepper
+My Steps Per MM is based on a 200 step per revolution motor and a threaded rod
+with 20 threads per inch. This means that I will have to step 4000 times to move
+the coupler one inch.
 
-  MAKE SURE THAT YOU HAVE CONFIGURED THE Rotor::Stepper WITH THE CORRECT GPIO PIN NUMBERS. CHECK AND 
-  DOUBLE CHECK THESE BEFORE RUNNING YOUR CODE.
+Usage
+=====
 
-    stepper = Rotor::Stepper.new(coil_A_1_pin, coil_A_2_pin, coil_B_1_pin, coil_B_2_pin, enable_pin=nil, homing_switch, homing_normally,steps_per_mm)
-    stepper.forward(delay=5,steps=100) # stepper.forward(1,100)
-    stepper.backwards(delay=5,steps=100)
-    stepper.set_home(direction) #:forward or :backwards
-    stepper.at_home?
-    stepper.at_safe_area? # opposite of at_home?
+Class Stepper
+-------------
 
-  After running your GCode, you may want to consider to power down the motor by sending a
-  LOW to each step.
+MAKE SURE THAT YOU HAVE CONFIGURED THE Rotor::Stepper WITH THE CORRECT GPIO PIN
+NUMBERS. CHECK AND DOUBLE CHECK THESE BEFORE RUNNING YOUR CODE. This has been
+tested with both Bipolar and Unipolar Stepper Motors
 
-    stepper.power_down
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+stepper = Rotor::Stepper.new(coil_A_1_pin, coil_A_2_pin, coil_B_1_pin, coil_B_2_pin, enable_pin=nil, homing_switch, homing_normally, steps_per_mm)
+stepper.forward(delay=5,steps=100) # stepper.forward(5,100)
+stepper.backwards(delay=5,steps=100)# stepper.backwards(5,100)
+stepper.set_home(direction) #:forward or :backwards
+stepper.at_home?
+stepper.at_safe_area? # opposite of at_home?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-## Class Servo
+After running your GCode, you may want to consider to power down the motor by
+sending a LOW to each step.
 
-    servo = Rotor::Servo.new(pin=18)
-    servo.rotate(direction) # :up or :down
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+stepper.power_down
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-## Class GCode
+Class Servo
+-----------
 
-  There was a bug when calculating the start and end angles. This has been fixed.
+You can use a servo to control the marker (or leave blank if you're using a Z
+Axis Stepper) This will be built out so that the strength control of the servo
+(for laser power) can be adjusted and inputs sent in. However, for development
+purposes, I recommend not playing with lasers, but rather get the machine and
+code working properly first.
 
-  The plot points are streamed to output.txt file on your computer.
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+servo = Rotor::Servo.new(pin=18)# Rotor::Servo.new(18)
+servo.rotate(direction) # :up or :down
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-  You can test the outputs of your GCODE and the XY plots it creates by Rotor.
+Class GCode
+-----------
 
-    File.open("output.txt", 'wb') { |file| file.write("x,y,xm,ym\n") }
-    gcode = Rotor::Gcode.new(nil,nil,nil,1,nil)
-    gcode.open('output.nc')
-    gcode.simulate
+The plot points are streamed to output.txt file on your computer.
 
-  The goal of this gem is to make controlling your robotics easier than
-  other solutions.
+You can test the outputs of your GCODE and the XY plots it creates by Rotor.
 
-  Added Homing Switch options where you can add the GPIO of the switch
-  and indicate if it is normally open or normally closed. I have my homing
-  switches on each axis configured in parallel since I know the direction
-  that the panel is moving in and therefore know which side it has hit. This
-  was to reduce the number of GPIO pins required.
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+File.open("output.txt", 'wb') { |file| file.write("x,y,xm,ym\n") }
+gcode = Rotor::Gcode.new(nil,nil,nil,1,nil)
+gcode.open('output.nc')
+gcode.simulate(accuracy=8,speed=1)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    stepper_x = Rotor::Stepper.new(23,12,17,24,nil,13,0,157.48)
-    stepper_y = Rotor::Stepper.new(25, 4,21,22,nil,19,0,157.48)
+When using the simulate option on the Gcode class, you can now enter additional
+parameters which will increase accuracy as well as speed. The accuracy
+parameter will be used in the logic of determining how many steps in the arc 
+will occur. The Max of the distance calculation and accuracy variable will be
+the number of steps on a given arc. The speed parameter is in ms and will be
+the delay between steps.
 
-  You can use a servo to control the marker (or leave blank if you're using a Z Axis Stepper)
-  This will be built out so that the strength control of the servo (for laser power) can be
-  adjusted and inputs sent in. However, for development purposes, I recommend not playing with
-  lasers, but rather get the machine and code working properly first.
+The goal of this gem is to make controlling your robotics easier than other
+solutions.
 
-    servo = Rotor::Servo.new(18)
+Added Homing Switch options where you can add the GPIO of the switch and
+indicate if it is normally open or normally closed. I have my homing switches on
+each axis configured in parallel since I know the direction that the panel is
+moving in and therefore know which side it has hit. This was to reduce the
+number of GPIO pins required.
 
-  You can send the stepper motor to the outter edges of the board.
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+stepper_x = Rotor::Stepper.new(23,12,17,24,nil,13,0,157.48)
+stepper_y = Rotor::Stepper.new(25, 4,21,22,nil,19,0,157.48)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    # stepper_x.set_home(:backwards)
-    # stepper_x.forward(1,100)
-    # stepper_y.set_home(:forward)
+You can send the stepper motor to the outter edges of the board. You will want
+to play with the :backwards and :forward options to make sure that they’re
+moving in the correct direction for your stepper motor.
 
-    stepper_x = Rotor::Stepper.new(23,12,17,24,nil,13,LOW,157.48)
-    stepper_y = Rotor::Stepper.new(25, 4,21,22,nil,19,LOW,157.48)
-    
-    loop do
-      puts "Enter steps forward::"
-      text = gets.chomp
-      
-      threads = []
-      threads << Thread.new { stepper_x.forward(5,text.to_i) }
-      threads << Thread.new { stepper_y.forward(5,text.to_i) }
-      threads.each { |thr| thr.join }
-
-      puts "Enter steps backward::"
-      text = gets.chomp
-
-      stepper_x.backwards(5,text.to_i)
-      stepper_y.backwards(5,text.to_i)
-    end
-
-# GCode Simulation
-
-GCode can be simulated (this is my latest part of the project) where
-a file can be read in and the movements interpreted. I'm still working
-on the ARC movement on G02 and G03, but have gotten G0 and G1 working.
-
-Enter each stepper motor (or nil if you do not have that particular axis)
-along with the scale (multiplies all coordinates by this. Typically you will
-keep this at 1).
-
-    #gcode = Rotor::Gcode.new(stepper_x,stepper_y,stepper_z,1,servo)
-    gcode = Rotor::Gcode.new(nil,nil,nil,1,nil)
-    gcode.open('sample.nc')
-    gcode.simulate
-
-# Asynchronous Movement
-
-  By default, if you run the first motor and then the second motor commands,
-  the first command will execute first and the second one will execute afterwards.
-  This may not always be the desired result as your plot/laser/mill may get ruined
-  by having nonsynchronous movements.
-
-  Since Ruby by default will not asynchronously execute commands, you can combine
-  the X/Y/Z movements into their own threads.
-
-    threads = []
-    threads << Thread.new { stepper_x.forward(5,text.to_i) }
-    threads << Thread.new { stepper_y.forward(5,text.to_i) }
-    threads.each { |thr| thr.join }
-
-# Sample Code
-
-## Production (Moving Stepper and Servo)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+stepper_x = Rotor::Stepper.new(23,12,17,24,nil,13,LOW,157.48)
+stepper_y = Rotor::Stepper.new(25, 4,21,22,nil,19,LOW,157.48)
+
+stepper_x.set_home(:backwards)
+stepper_y.set_home(:forward)
+
+loop do
+  puts "Enter steps forward::"
+  text = gets.chomp
   
-  Here is the real world sample code that I am using to plot
-
-    require 'rotor'
-    begin
-      stepper_x = Rotor::Stepper.new(23,12,17,24,nil,13,0,157.48)
-      stepper_y = Rotor::Stepper.new(25, 4,21,22,nil,19,0,157.48)
-      servo = Rotor::Servo.new(18)
-
-      stepper_x.set_home(:backwards)
-      stepper_y.set_home(:backwards)
-      stepper_x.forward(1,4000)
-      stepper_y.forward(1,4000)
-
-      gcode = Rotor::Gcode.new(stepper_x,stepper_y,nil,1,servo)
-      gcode.open('output.nc')
-      gcode.simulate
-
-    ensure
-      servo.rotate(:up)
-
-      stepper_x.set_home(:backwards)
-      stepper_y.set_home(:backwards)
-      stepper_x.forward(1,4000)
-      stepper_y.forward(1,4000)
-
-      stepper_x.power_down
-      stepper_y.power_down
-
-      [23,12,17,24,13,25,4,21,22,19,13].each do |pin|
-       `echo #{pin} > /sys/class/gpio/unexport`
-      end
-    end
-
-## Development (Exporting Plot Points for Graphing)
+  threads = []
+  threads << Thread.new { stepper_x.forward(5,text.to_i) }
+  threads << Thread.new { stepper_y.forward(5,text.to_i) }
+  threads.each { |thr| thr.join }
 
-  Before wasting more materials, I try to plot my points to a file and view them in Excel.
-  Within the root of this repository, there is an Excel file, called Visual.xlsx, and 
-  you can import the output.txt into the first four columns. By doing so, you can see the 
-  plot points and the scatter of movements.
+  puts "Enter steps backward::"
+  text = gets.chomp
+
+  stepper_x.backwards(5,text.to_i)
+  stepper_y.backwards(5,text.to_i)
+end
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+GCode Simulation
+================
+
+GCode can be simulated (this is my latest part of the project) where a file can
+be read in and the movements interpreted. Right now, G02 and G03 will work with
+I and J offsets. Radius is not currently supported.
+
+Enter each stepper motor (or nil if you do not have that particular axis) along
+with the scale (multiplies all coordinates by this. Typically you will keep this
+at 1).
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#gcode = Rotor::Gcode.new(stepper_x,stepper_y,stepper_z,1,servo)
+gcode = Rotor::Gcode.new(nil,nil,nil,1,nil)
+gcode.open('sample.nc')
+gcode.simulate(accuracy=8,speed=1)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+By passing nil into each stepper motor and servo, you can simulate the GCode
+execution.
+
+Asynchronous Movement
+=====================
+
+By default, if you run the first motor and then the second motor commands, the
+first command will execute first and the second one will execute afterwards.
+This may not always be the desired result as your plot/laser/mill may get ruined
+by having nonsynchronous movements.
+
+Since Ruby by default will not asynchronously execute commands, you can combine
+the X/Y/Z movements into their own threads.
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+threads = []
+threads << Thread.new { stepper_x.forward(5,text.to_i) }
+threads << Thread.new { stepper_y.forward(5,text.to_i) }
+threads.each { |thr| thr.join }
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Sample Code
+===========
+
+Production (Moving Stepper and Servo)
+-------------------------------------
+
+Here is the real world sample code that I am using to plot
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+require 'rotor'
+begin
+  stepper_x = Rotor::Stepper.new(23,12,17,24,nil,13,0,157.48)
+  stepper_y = Rotor::Stepper.new(25, 4,21,22,nil,19,0,157.48)
+  servo = Rotor::Servo.new(18)
+
+  stepper_x.set_home(:backwards)
+  stepper_y.set_home(:backwards)
+
+  #My threaded rods move 1 inch per 4000 steps (Stepper Motor has 200 steps/rev and    the rod has 20 threads per inch)
+
+  stepper_x.forward(1,40)
+  stepper_y.forward(1,40)
+
+  gcode = Rotor::Gcode.new(stepper_x,stepper_y,nil,1,servo)
+  gcode.open('output.nc')
+  gcode.simulate(accuracy=8,speed=5)
+
+ensure
+  servo.rotate(:up)
+
+  stepper_x.set_home(:backwards)
+  stepper_y.set_home(:backwards)
+  stepper_x.forward(1,4000)
+  stepper_y.forward(1,4000)
+
+  stepper_x.power_down
+  stepper_y.power_down
+
+  [23,12,17,24,13,25,4,21,22,19,13].each do |pin|
+   `echo #{pin} > /sys/class/gpio/unexport`
+  end
+end
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Based on the code above, my origin (0,0) is one inch from the backwards X and
+one inch from the backwards Y
+
+Development (Exporting Plot Points for Graphing)
+------------------------------------------------
+
+Before wasting more materials, I try to plot my points to a file and view them
+in Excel. Within the root of this repository, there is an Excel file, called
+Visual.xlsx, and you can import the output.txt into the first four columns. By
+doing so, you can see the plot points and the scatter of movements. Go to the
+data tab and click Refresh Data. Select the output.txt file that you generated
+and it will show the plot points. If you see some crazy stray points, you can
+put in a issue and I will look at it. Please include the GCode that you’re using
+that is causing problems.
 
-    File.open("output.txt", 'wb') { |file| file.write("x,y,xm,ym\n") }
-    gcode = Rotor::Gcode.new(nil,nil,nil,1,nil)
-    gcode.open('output.nc')
-    gcode.simulate
+Keep in mind that this keeps track of the coordinates, so you will see the entry
+and exit points as lines. This is expected behavior since I like to see where my
+marker is entering into an object.
 
-# License
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+File.open("output.txt", 'wb') { |file| file.write("x,y,xm,ym\n") }
+gcode = Rotor::Gcode.new(nil,nil,nil,1,nil)
+gcode.open('output.nc')
+gcode.simulate
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+License
+=======
 
 Copyright (c) 2015 kobaltz
 
 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.
+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/lib/rotor/gcode.rb

@@ -12,19 +12,14 @@ module Rotor
       @file = File.open(file)
     end
 
-    def simulate
+    def simulate(accuracy=8,speed=1)
       @x = 0
       @y = 0
       @z = 0
 
       line_num = 0
-      last_parsed_line = nil
 
       @file.each_line do |line|
-        # puts "last_parsed_line::#{last_parsed_line}"
-        # line = line.gsub("J-0.000000","J-0.000001") if last_parsed_line && last_parsed_line[:j] && last_parsed_line[:j] > 0.0
-        # line = line.gsub("J-0.000000","J0.000001") if last_parsed_line && last_parsed_line[:j] && last_parsed_line[:j] < 0.0
-
         parsed_line = parse_line(line)
         
         line_num += 1
@@ -34,29 +29,32 @@ module Rotor
             if parsed_line[:z] && parsed_line[:f] && parsed_line[:x].nil? && parsed_line[:y].nil? 
               puts "Lowering marker"
               @servo.rotate(:down) if @servo
+              @stepper_z.forward(5,25) if @stepper_z
             elsif parsed_line[:z] && parsed_line[:f].nil? && parsed_line[:x].nil? && parsed_line[:y].nil? 
               puts "Raising marker::#{parsed_line}"
+              @stepper_z.backwards(5,25) if @stepper_z
               @servo.rotate(:up) if @servo
             else
               puts "Move Stepper::#{parsed_line}"
-              move_stepper(parsed_line,1)
+              move_stepper(parsed_line,speed)
             end
           elsif parsed_line[:g] == 1
             if parsed_line[:z] && parsed_line[:f] && parsed_line[:x].nil? && parsed_line[:y].nil? 
               puts "Lowering marker"
               @servo.rotate(:down) if @servo
+              @stepper_z.forward(5,25) if @stepper_z
             elsif parsed_line[:z] && parsed_line[:f].nil? && parsed_line[:x].nil? && parsed_line[:y].nil? 
               puts "Raising marker::#{parsed_line}"
+              @stepper_z.backwards(5,25) if @stepper_z
               @servo.rotate(:up) if @servo
             elsif parsed_line[:z].nil? && parsed_line[:f] && parsed_line[:x].nil? && parsed_line[:y].nil? 
               # Set feed/spin rate
             else
               puts "Move Stepper::#{parsed_line}"
-              move_stepper(parsed_line,1)
+              move_stepper(parsed_line,speed)
             end
           elsif parsed_line[:g] == 2 || parsed_line[:g] == 3
             # Get my ARC on
-            # puts "DEBUG::#{parsed_line}"
             ignore = false
 
             x_start = @x
@@ -67,11 +65,7 @@ module Rotor
 
             if parsed_line[:i] && parsed_line[:j] && parsed_line[:r].nil?
               x_offset = parsed_line[:i]
-              # x_offset = 0.0001 if x_offset == 0.0
-              # x_offset = -0.0001 if x_offset == -0.0
               y_offset = parsed_line[:j]
-              # y_offset = 0.0001 if y_offset == 0.0
-              # y_offset = -0.0001 if y_offset == -0.0
 
               x_origin = x_offset + x_start
               y_origin = y_offset + y_start
@@ -84,7 +78,7 @@ module Rotor
 
             unless ignore
               distance = Math.sqrt((x_start - x_end) ** 2 + (y_start - y_end) ** 2)
-              number_of_precision = [distance.to_i,4].max
+              number_of_precision = [distance.to_i,8].max
               start_angle = Math.atan2((y_start - y_origin),(x_start - x_origin))
               end_angle = Math.atan2((y_end - y_origin),(x_end - x_origin))
 
@@ -108,7 +102,7 @@ module Rotor
               arc_line[:y] = radius * Math.sin(current_degrees) + y_origin
               arc_line[:z] = nil
               puts "Move Arc Stepper (#{line_num})::#{arc_line}::#{start_angle},#{end_angle}"
-              move_stepper(arc_line,1)
+              move_stepper(arc_line,speed)
             end unless ignore
 
           else
@@ -130,7 +124,6 @@ module Rotor
           # puts "Something else"
           puts "DEBUG::????? - Something else::#{parsed_line}"
         end
-        last_parsed_line = parsed_line
       end
     end
 
@@ -197,7 +190,7 @@ module Rotor
         end
         @z = @z_move
       end      
-      # puts "Moving to G#{parsed_line[:g]} #{@x_move}(#{@x_movement}), #{@y_move}(#{@y_movement}), #{@z_move}(#{@z_movement})"
+      puts "Moving to G#{parsed_line[:g]} #{@x_move}(#{@x_movement}), #{@y_move}(#{@y_movement}), #{@z_move}(#{@z_movement})"
       threads.each { |thr| thr.join }
       File.open("output.txt", 'a') { |file| file.write("#{@x_move},#{@y_move},#{@x_movement},#{@y_movement}\n") } if File.exists?("output.txt")
     end    

data/lib/rotor/stepper.rb

@@ -61,8 +61,8 @@ module Rotor
       puts "Setting #{direction} with Homing on GPIO #{@homing_switch}"
       @move = true
       while @move == true
-        backwards(1,158) if direction == :backwards #&& @io.read(@homing_switch) == @homing_normally
-        forward(1,158) if direction == :forward #&& @io.read(@homing_switch) == @homing_normally
+        backwards(1,1) if direction == :backwards && @io.read(@homing_switch) == @homing_normally
+        forward(1,1) if direction == :forward && @io.read(@homing_switch) == @homing_normally
         @move = false unless @io.read(@homing_switch) == @homing_normally
       end
     end

data/lib/rotor/version.rb

@@ -1,3 +1,3 @@
 module Rotor
-  VERSION = "0.1.2"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rotor
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.5
 platform: ruby
 authors:
 - kobaltz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-23 00:00:00.000000000 Z
+date: 2015-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -59,15 +59,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".DS_Store"
 - ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
-- lib/.DS_Store
 - lib/rotor.rb
-- lib/rotor/.DS_Store
 - lib/rotor/gcode.rb
 - lib/rotor/servo.rb
 - lib/rotor/stepper.rb