RubyGems - beaglebone - Versions diffs - 1.0.6 → 1.1.0 - Mend

beaglebone 1.0.6 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

data/examples/ain.rb DELETED Viewed

@@ -1,92 +0,0 @@
-#!/usr/bin/env ruby
-require 'beaglebone'
-require 'pp'
-include  Beaglebone
-#analog testing
-#oo methods
-#analog read
-p9_33 = AINPin.new(:P9_33)
-loop do
-  puts p9_33.read
-  sleep 0.01
-end
-exit
-#waiting for analog input change
-p9_33 = AINPin.new(:P9_33)
-pp p9_33.wait_for_change(10, 0.01)
-pp p9_33.wait_for_change(10, 0.01)
-pp p9_33.wait_for_change(10, 0.01)
-#background analog input with callback
-#wait for threshold
-callback = lambda { |pin, mv_last, mv, state_last, state, count|
-  puts "[#{count}] #{pin} #{state_last} -> #{state}     #{mv_last} -> #{mv}"
-}
-p9_33 = AINPin.new(:P9_33)
-p9_33.run_on_threshold(callback, 400, 1200, 5, 0.001)
-sleep 5
-p9_33.stop_wait
-pp p9_33.wait_for_threshold(200, 1600, 100, 0.01)
-pp p9_33.wait_for_threshold(200, 1600, 100, 0.01)
-pp p9_33.wait_for_threshold(200, 1600, 100, 0.01)
-#wait for change
-callback = lambda { |pin, mv_last, mv, count| puts "[#{count}] #{pin} #{mv_last} -> #{mv}" }
-p9_33 = AINPin.new(:P9_33)
-p9_33.run_on_change(callback, 10, 0.1)
-sleep 5
-p9_33.stop_wait
-exit
-#procedural methods
-#analog read
-loop do
-  puts AIN.read(:P9_33)
-  sleep 0.01
-end
-exit
-#wait for analog input to hit a certrain threshold limit
-pp AIN.wait_for_threshold(:P9_33, 200, 1600, 100, 0.01)
-pp AIN.wait_for_threshold(:P9_33, 200, 1600, 100, 0.01)
-pp AIN.wait_for_threshold(:P9_33, 200, 1600, 100, 0.01)
-pp AIN.wait_for_threshold(:P9_33, 200, 1600, 100, 0.01)
-pp AIN.wait_for_threshold(:P9_33, 200, 1600, 100, 0.01)
-exit
-#waiting for analog input change
-pp AIN.wait_for_change(:P9_33, 10, 0.01)
-pp AIN.wait_for_change(:P9_33, 10, 0.01)
-pp AIN.wait_for_change(:P9_33, 10, 0.01)
-exit
-#background analog input
-callback = lambda { |pin, mv_last, mv, count| puts "[#{count}] #{pin} #{mv_last} -> #{mv}" }
-AIN.run_on_change(callback, :P9_33, 10, 0.1)
-sleep 5
-AIN.stop_wait(:P9_33)
-#run when reaching a certain threshold
-callback = lambda { |pin, mv_last, mv, state_last, state, count|
-  puts "[#{count}] #{pin} #{state_last} -> #{state}     #{mv_last} -> #{mv}"
-}
-AIN.run_on_threshold(callback, :P9_33, 400, 1200, 5, 0.001)
-loop do sleep(4000);end
-exit

data/examples/gpio.rb DELETED Viewed

@@ -1,196 +0,0 @@
-#!/usr/bin/env ruby
-require 'beaglebone'
-include  Beaglebone
-###object oriented methods###
-#flash leds
-led1 = GPIOPin.new(:USR0, :OUT)
-led2 = GPIOPin.new(:USR1, :OUT)
-led3 = GPIOPin.new(:USR2, :OUT)
-led4 = GPIOPin.new(:USR3, :OUT)
-5.times do
-  led1.digital_write(:HIGH)
-  sleep 0.25
-  led1.digital_write(:LOW)
-  led2.digital_write(:HIGH)
-  sleep 0.25
-  led2.digital_write(:LOW)
-  led3.digital_write(:HIGH)
-  sleep 0.25
-  led3.digital_write(:LOW)
-  led4.digital_write(:HIGH)
-  sleep 0.25
-  led4.digital_write(:LOW)
-end
-exit
-#basic GPIO reads and writes
-p9_11 = GPIOPin.new(:P9_11, :IN)
-p9_12 = GPIOPin.new(:P9_12, :OUT)
-puts p9_11.digital_read
-p9_12.digital_write(:HIGH)
-puts p9_11.digital_read
-p9_12.digital_write(:LOW)
-puts p9_11.digital_read
-exit
-##gpio edge trigger with callback
-p9_11 = GPIOPin.new(:P9_11, :IN)
-p9_12 = GPIOPin.new(:P9_12, :OUT)
-#toggle output pin randomly in a separate there
-Thread.new do
-  loop do
-    sleep rand(100) / 100.0
-    p9_12.digital_write(:LOW)
-    sleep rand(100) / 100.0
-    p9_12.digital_write(:HIGH)
-  end
-end
-#run on edge trigger with callback
-callback = lambda { |pin,edge,count| p9_11.stop_edge_wait if count == 10;puts "[#{count}] #{pin} #{edge}"}
-p9_11.run_on_edge(callback, :BOTH)
-sleep 10000
-exit
-#or without callback
-loop do
-  edge = p9_11.wait_for_edge(:RISING)
-  puts "!! TRIGGERED ON #{edge}"
-  edge = p9_11.wait_for_edge(:RISING)
-  puts "!! TRIGGERED ON #{edge}"
-  edge = p9_11.wait_for_edge(:BOTH)
-  puts "!! TRIGGERED ON #{edge}"
-end
-#gpio edge trigger
-p9_11 = GPIOPin.new(:P9_11, :IN)
-p9_12 = GPIOPin.new(:P9_12, :OUT)
-Thread.new do
-  loop do
-    sleep rand(100) / 100.0
-    p9_12.digital_write(:LOW)
-    sleep rand(100) / 100.0
-    p9_12.digital_write(:HIGH)
-  end
-end
-loop do
-  edge = p9_11.wait_for_edge(:RISING)
-  puts "!! TRIGGERED ON #{edge}"
-  edge = p9_11.wait_for_edge(:RISING)
-  puts "!! TRIGGERED ON #{edge}"
-  edge = p9_11.wait_for_edge(:BOTH)
-  puts "!! TRIGGERED ON #{edge}"
-end
-#shift register via gpio, specified latch, clock, and data pins
-shiftreg = ShiftRegister.new(:P9_11, :P9_12, :P9_13)
-data = 255
-shiftreg.shiftout(data)
-exit
-###procedural methods###
-#gpio edge trigger callback
-GPIO.pin_mode(:P9_12, :OUT)
-GPIO.pin_mode(:P9_11, :IN)
-GPIO.run_on_edge(lambda { |pin,edge,count| puts "[#{count}] #{pin} -- #{edge}" }, :P9_11, :BOTH)
-leds = [ :USR0, :USR1, :USR2, :USR3 ]
-leds.each do |ledpin|
-  GPIO.pin_mode(ledpin, :OUT)
-end
-x = 0
-loop do
-#gpio write to led pins
-  leds.each do |ledpin|
-    GPIO.digital_write(ledpin, :LOW)
-  	sleep 0.25
-    GPIO.digital_write(ledpin, :HIGH)
-  end
-	x += 1
-	if x == 10
-		GPIO.stop_edge_wait(:P9_11)
-		puts 'STOP'
-	end
-  if x == 15
-    GPIO.run_on_edge(lambda { |pin,edge,count| puts "[#{count}] #{pin} -- #{edge}" }, :P9_11, :BOTH)
-		puts 'OK GO AGAIN'
-		x = 0
-	end
-end
-exit
-#gpio edge trigger
-GPIO.pin_mode(:P9_12, :OUT)
-GPIO.pin_mode(:P9_11, :IN)
-loop do
-	edge = GPIO.wait_for_edge(:P9_11, :RISING)
-	puts "!! TRIGGERED ON #{edge}"
-end
-#standard gpio setup and testing
-GPIO.pin_mode(:P9_12, :OUT)
-puts GPIO.enabled?(:P9_12)
-puts GPIO.get_gpio_mode(:P9_12)
-#gpio setup for led pins
-leds = [ :USR0, :USR1, :USR2, :USR3 ]
-leds.each do |ledpin|
-	GPIO.pin_mode(ledpin, :OUT)
-end
-#gpio write to led pins
-leds.each do |ledpin|
-	GPIO.digital_write(ledpin, :LOW)
-end
-#gpio write
-loop do
-	GPIO.digital_write(:P9_12, :HIGH)
-	sleep 0.25
-	GPIO.digital_write(:P9_12, :LOW)
-	sleep 0.25
-end
-GPIO.cleanup
-exit
-# gpio read
-GPIO.pin_mode(:P9_12, :IN)
-loop do
-	puts GPIO.digital_read(:P9_12)
-end

data/examples/i2c.rb DELETED Viewed

@@ -1,110 +0,0 @@
-#!/usr/bin/env ruby
-require 'beaglebone'
-#i2c testing hooked up to LSM303DLHC
-#oo method
-i2c = I2CDevice.new(:I2C2)
-#put mag into continuous conversation mode
-i2c.write(0x1e, [0x02, 0x00].pack("C*"))
-#enable temperatuer sensor, 15hz register update
-i2c.write(0x1e, [0x00, 0b10010000].pack("C*") )
-#delay for the settings to take effect
-sleep(0.1)
-loop do
-  #read axis data
-  raw = i2c.read(0x1e, 6, [0x03].pack("C*"))
-  #coordinates are signed shorts in x,z,y order
-  x,z,y = raw.unpack("s>*")
-  #calculate angle
-  degrees = (Math::atan2(y, x) * 180) / Math::PI
-  degrees += 360 if degrees < 0
-  #read 2 bytes from temperature register
-  raw = i2c.read(0x1e, 2, [0x31].pack("C*"))
-  #temperature is sent big endian, lsd last
-  temp = raw.unpack("S>").first
-  #temp is 12 bits, last 4 are unused
-  temp = temp >> 4
-  #twos complement
-  temp -= 65535 if temp > 32767
-  #each bit is 8c
-  temp /= 8
-  #correction factor
-  temp += 19
-  #convert to f
-  temp = (temp * 1.8 + 32).to_i
-  puts "#{Time.now.strftime("%H:%M")}  temp: #{temp} degrees f        direction: #{degrees.to_i} degrees"
-  sleep 1
-end
-exit
-#procedural method
-#i2c testing
-I2C.setup(:I2C2)
-#put mag into continuous conversation mode
-I2C.write(:I2C2, 0x1e, [0x02, 0x00].pack("C*"))
-#enable temperatuer sensor, 15hz register update
-I2C.write(:I2C2, 0x1e, [0x00, 0b10010000].pack("C*") )
-#delay for the settings to take effect
-sleep(0.1)
-loop do
-  #read axis data
-  raw = I2C.read(:I2C2, 0x1e, 6, [0x03].pack("C*"))
-  #coordinates are signed shorts in x,z,y order
-  x,z,y = raw.unpack("s>*")
-  #calculate angle
-  degrees = (Math::atan2(y, x) * 180) / Math::PI
-  degrees += 360 if degrees < 0
-  #read 2 bytes from temperature register
-  raw = I2C.read(:I2C2, 0x1e, 2, [0x31].pack("C*"))
-  #temperature is sent big endian, lsd last
-  temp = raw.unpack("S>").first
-  #temp is 12 bits, last 4 are unused
-  temp = temp >> 4
-  #twos complement
-  temp -= 65535 if temp > 32767
-  #each bit is 8c
-  temp /= 8
-  #correction factor
-  temp += 19
-  #convert to f
-  temp = (temp * 1.8 + 32).to_i
-  puts "#{Time.now.strftime("%H:%M")}  temp: #{temp} degrees f        direction: #{degrees.to_i} degrees"
-  sleep 60
-end
-exit

data/examples/pwm.rb DELETED Viewed

@@ -1,63 +0,0 @@
-#!/usr/bin/env ruby
-require 'beaglebone'
-include  Beaglebone
-#pwm example
-#oo method
-p9_14 = PWMPin.new(:P9_14, 90, 10, :NORMAL)
-sleep 1
-p9_14.set_frequency(20)
-sleep(1)
-p9_14.set_duty_cycle(95)
-sleep(1)
-p9_14.set_duty_cycle(50)
-sleep(1)
-p9_14.set_frequency(2)
-sleep(1)
-p9_14.stop
-sleep(1)
-p9_14.run
-sleep(1)
-p9_14.set_frequency(32)
-sleep(1)
-p9_14.set_duty_cycle(94)
-sleep(1)
-p9_14.set_period_ns(31250000)
-p9_14.set_duty_cycle_ns(31250000)
-p9_14.set_period_ns(31249999)
-p9_14.set_duty_cycle(10)
-p9_14.set_polarity(:INVERTED)
-p9_14.disable_pwm_pin
-exit
-#procedural method
-PWM.start(:P9_14, 90, 10, :NORMAL)
-sleep(1)
-PWM.set_frequency(:P9_14, 20)
-sleep(1)
-PWM.set_duty_cycle(:P9_14, 95)
-sleep(1)
-PWM.set_duty_cycle(:P9_14, 50)
-sleep(1)
-PWM.set_frequency(:P9_14, 2)
-sleep(1)
-PWM.stop(:P9_14)
-sleep(1)
-PWM.run(:P9_14)
-sleep(1)
-PWM.set_frequency(:P9_14, 32)
-sleep(1)
-PWM.set_duty_cycle(:P9_14, 94)
-sleep(1)
-PWM.set_period_ns(:P9_14, 31250000)
-PWM.set_duty_cycle_ns(:P9_14, 31250000)
-PWM.set_period_ns(:P9_14, 31249999)
-PWM.set_duty_cycle(:P9_14, 10)
-PWM.set_polarity(:P9_14, :INVERTED)
-sleep(1)
-PWM.cleanup
-exit

data/examples/shiftregister.rb DELETED Viewed

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-require 'beaglebone'
-include  Beaglebone
-#shift reg via gpio
-shiftreg = ShiftRegister.new(:P9_11, :P9_12, :P9_13)
-data = 255
-shiftreg.shift_out(data)
-exit

data/examples/spi.rb DELETED Viewed

@@ -1,62 +0,0 @@
-#!/usr/bin/env ruby
-require 'beaglebone'
-include  Beaglebone
-#SPI test hooked up to MCP3008
-#oo methods
-spi = SPIDevice.new(:SPI0)
-loop do
-  # communicate with MCP3008
-  # byte 1: start bit
-  # byte 2: single(1)/diff(0),3 bites for channel, null pad
-  # byte 3: don't care
-  raw = spi.xfer([ 0b00000001, 0b10000000, 0].pack("C*"))
-  data = raw.unpack("C*")
-  val = ((data[1] & 0b00000011) << 8 ) | data[2]
-  puts val
-  raw = spi.xfer([ 0b00000001, 0b10010000, 0].pack("C*"))
-  data = raw.unpack("C*")
-  val = ((data[1] & 0b00000011) << 8 ) | data[2]
-  puts val
-  sleep 0.25
-end
-exit
-#procedural methods
-SPI.setup(:SPI0)
-loop do
-  # communicate with MCP3008
-  # byte 1: start bit
-  # byte 2: single(1)/diff(0),3 bites for channel, null pad
-  # byte 3: don't care
-  raw = SPI.xfer(:SPI0, [ 0b00000001, 0b10000000, 0].pack("C*"))
-  data = raw.unpack("C*")
-  val = ((data[1] & 0b00000011) << 8 ) | data[2]
-  puts val
-  raw = SPI.xfer(:SPI0, [ 0b00000001, 0b10010000, 0].pack("C*"))
-  data = raw.unpack("C*")
-  val = ((data[1] & 0b00000011) << 8 ) | data[2]
-  puts val
-  sleep 0.25
-end
-exit

data/examples/uart.rb DELETED Viewed

@@ -1,64 +0,0 @@
-#!/usr/bin/env ruby
-require 'beaglebone'
-#uart example
-#oo method
-uart1 = UARTDevice.new(:uart1, 9600)
-uart1.writeln("TEST")
-puts uart1.readchars(10)
-puts uart1.readchar
-puts uart1.readline
-callback = lambda { |uart, line, count| puts "[#{uart}:#{count}] #{line} "}
-#uart1.run_on_each_chars(callback, 3, 3)
-#uart1.run_on_each_chars(callback, 3)
-#uart1.run_on_each_char(callback, 3)
-#uart1.run_once_on_each_chars(callback, 3)
-#uart1.run_once_on_each_char(callback)
-#uart1.run_on_each_chars(callback, 2)
-uart1.run_on_each_line(callback)
-sleep(5)
-uart1.stop_read_wait
-uart1.each_chars(2) { |c| puts c }
-#uart1.each_line { |line| puts line }
-uart1.disable
-exit
-#procedural method
-UART.setup(:UART1, 9600)
-UART.write(:UART1, "test1")
-#puts UART.readchars(:UART1, 10)
-#puts UART.readchar(:UART1)
-#puts UART.readline(:UART1)
-callback = lambda { |uart, line, count| puts "[#{uart}:#{count}] #{line} "}
-#UART.run_on_each_chars(callback, :UART1, 3, 3)
-#UART.run_on_each_chars(callback, :UART1, 3)
-#UART.run_on_each_char(callback, :UART1, 3)
-#UART.run_once_on_each_chars(callback, :UART1, 3)
-#UART.run_once_on_each_char(callback, :UART1)
-#UART.run_on_each_chars(callback, :UART1, 2)
-UART.run_on_each_line(callback, :UART1)
-sleep(5)
-UART.stop_read_wait(:UART1)
-UART.each_chars(:UART1, 2) { |c| puts c }
-#UART.each_line(:UART1) { |line| puts line }
-UART.cleanup
-exit