beaglebone 1.0.6 → 1.1.0

data/examples/ain.rb

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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