atduskgreg-rad 0.2.5

data/lib/examples/hello_array_eeprom.rb

@@ -0,0 +1,59 @@
+class HelloArrayEeprom < ArduinoSketch
+
+   # ----------------------------------------------------------------------
+   #    Checking out various array operations  with I2C serial EEPROM
+   #      doing block writes and bloack readbacks with byte arrays
+   #
+   #      JD Barnhart - Seattle, WA July 2008
+   #      Brian Riley - Underhill Center, VT, USA  July 2008
+   #                     <brianbr@wulfden.org>
+   #
+   # ----------------------------------------------------------------------
+
+ # still working this out...
+ # for example, new instance style array declaration naming
+ # is at odds with original style array naming  
+
+ define "THROWAWAY 0"
+
+ # when we just need to declare an array, or need more control, such as specific type requirements
+ array "byte page_data[20] = {'R', 'A', 'D', ' ', 'i', 's', ' ', 'B', 'A', 'D', '*', '!', ')', '=', 'P', '-', '+', 'R', 'I', 'K'}"
+ array "byte in_buffer[20]"
+ 
+ output_pin 19, :as => :mem0, :device => :i2c_eeprom, :address => 1     # w/o :address defaults to  :address => 0  which is  0x50
+ output_pin 14, :as => :my_lcd, :device => :pa_lcd, :rate => 19200
+ 
+ 
+ def setup
+   
+   my_lcd.clearscr    "  I2C EEPROM Demo"
+   my_lcd.setxy 0, 1, "block write and read"
+   my_lcd.setxy 0, 2, "  back and display"
+   my_lcd.setxy 0, 3, "    to the LCD"
+   
+   delay 2000
+   
+   my_lcd.clearscr    "  I2C EEPROM Demo?n    block write"
+
+   mem0.write_page 0x0100, page_data, 20 
+
+   delay 1000
+   
+   my_lcd.clearline 1, "  block readback"
+   
+   mem0.read_buffer 0x0100, in_buffer, 20 
+   
+   my_lcd.setxy 0, 2
+   
+   1.upto(20) do |x|
+     my_lcd.print in_buffer[x-1]
+     my_lcd.print " "
+   end
+   
+ end
+ 
+ def loop
+    x = THROWAWAY
+ end
+
+end

data/lib/examples/hello_clock.rb

@@ -0,0 +1,84 @@
+class HelloClock < ArduinoSketch
+  
+# ----------------------------------------------------------------------------------
+#   <b>Time and Temp  (20 July 2008)</b>
+#   Example #1 - Brian Riley, Underhill Center, VT USA <brianbr@wulden.org>
+#   
+#   Connections
+#     I2C bus - DS1307 Real Time Clock chip
+#     Analog 0 (a.k.a Digital 14) - Wulfden K107 seria LCD Controller
+#                                   Peter Anderson chip
+#
+#   Comment
+#     - This is a straight forward program to read the Real Time Clock and Display
+#     delay() calls waiting for temperature conversion readings
+#
+#     - for the external data busses make sure you have 4.7K pullup resistors on the 
+#      the SDA/SCL (I2C)
+#
+# ----------------------------------------------------------------------------------
+ 
+    @flag    = int
+
+    array "byte clock[8]"
+    
+    @days   = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]
+    @months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]
+
+                              # implicit in :device => :ds1307 is that this i i2c
+                              # :enable => true issues the Wire.begin to ick over i2c
+    output_pin 19, :as => :rtc, :device => :i2c_ds1307, :enable => :true
+                              # software serial tx drives LCD display, screen cleared at startup
+                              # defines the softare protocol for controller as Peter Anderson
+    output_pin 14, :as => :myLCD, :device => :pa_lcd, :rate => 19200, :clear_screen => :true
+    loop_timer :as => :mainloop
+    
+
+    def setup
+      myLCD.clearscr "   --<Date/Time>--"
+      myLCD.setxy 1,3, "looptime = "
+      rtc.get clock, 1
+      print_main
+      @flag = 1
+    end
+    
+    def loop
+        mainloop.track
+        myLCD.setxy 12,3,  mainloop.get_total
+        rtc.get clock, 1
+        if clock[0] == 0
+          if @flag == 0
+            print_main
+            @flag = 1
+          end
+        else
+          @flag = 0
+        end
+       	myLCD.setxy 6,2
+       	printlz clock[2]
+       	myLCD.print ":"
+  	    printlz clock[1]
+       	myLCD.print ":"
+  	    printlz clock[0]
+
+       delay 50
+        
+    end
+
+    def	printlz(w)
+    			myLCD.print "0" if w < 10
+    			myLCD.print w
+    end
+
+    def	print_main
+ 	    myLCD.setxy 1,1, @days[clock[3]-1]
+		  myLCD.print ", "
+      myLCD.print @months[clock[5]-1]
+   	  myLCD.print " "
+      printlz clock[4]
+   	  myLCD.print ", "
+      printlz clock[6] + 2000
+      
+    end
+    
+end

data/lib/examples/hello_eeprom.rb

@@ -0,0 +1,51 @@
+class HelloEeprom < ArduinoSketch
+  
+  output_pin 19, :as => :rtc, :device => :i2c_ds1307, :enable => :true
+  output_pin 19, :as => :mem0, :device => :i2c_eeprom
+
+  output_pin 14, :as => :myLCD, :device => :pa_lcd, :rate => 19200
+    
+  def loop
+	    myLCD.setxy 0,0					# set to 0,0
+	    myLCD.print rtc.get(5, 1)	# refresh registers (=1) get month
+     	myLCD.print "/"
+	    myLCD.print rtc.get(4, 0)	# no need to refresh (=0) get day 
+     	myLCD.print "/"
+	    myLCD.print rtc.get(6, 0)	# get year
+     	myLCD.setxy(0,1)			# set in 1 byte line 1 (second line)
+     	printlz 2					# print hours with lead zero
+     	myLCD.print ":"
+	    printlz 1					# print minutes with lead zero
+     	myLCD.print ":"
+	    printlz 0					# print seconds with lead zero
+	    
+
+		myLCD.setxy 10,0
+		myLCD.print "write test"
+		myLCD.setxy 0,2
+		32.upto(109) do				# write address of byte to that b yte
+			|x| mem0.write_byte  x, x
+			myLCD.print(".") if x%2
+			delay 10
+		end
+
+		delay 2000
+		
+		myLCD.clearline 2 	# clears bottom two lines           
+		myLCD.clearline 3
+
+		myLCD.setxy 10,0, "read test "
+		myLCD.setxy 0,2
+									# read and print 39 addresses with printable numbers
+		75.upto(113) { |x| myLCD.print(mem0.read_byte(x)) }
+		delay 10000
+		myLCD.clearscr
+  end
+  
+  def	printlz(w)
+  			i = 0 + rtc.get(w,0)         # the '0 +' is YARH (Yet Another RubyToc Hack)
+  			myLCD.print "0" if i < 10
+  			myLCD.print i
+  end
+
+end

data/lib/examples/hello_eeprom_lcdpa.rb

@@ -0,0 +1,81 @@
+class HelloEepromLcdpa < ArduinoSketch
+  # -----------------------------------------------------------------------
+  #    Simple Byte Write and Byte Read-back of I2C EEPROM
+  #
+  #      Brian Riley - Underhill Center, VT, USA  July 2008
+  #                     <brianbr@wulfden.org>
+  #
+  #    I2C Routines are in a plugin not a library
+  #    No block reads and write yet
+  #    Displays to PH Anderson based serial LCD Display
+  #
+  #    <b>I2C Serial EEPROM - Byte Read and Byte Write</b>
+  #      
+  #     i2c_eeprom_write_byte  dev_addr, chip_addr, value
+  #
+  #     dev_addr (byte) - range 0x50 to 0x57 determined by hardware wiring 
+  #     chip_addr (unsigned) - 0 to as much as 64K, depends on chip
+  #     value (byte) - 0 to 255 (0x00 to 0xFF)
+  #
+  #     returns - nothing
+  #
+  #     i2c_eeprom_read_byte  dev_addr, chip_addr
+  #
+  #     dev_addr (byte) - range 0x50 to 0x57 determined by hardware wiring 
+  #     chip_addr (unsigned) - 0 to as much as 64K, depends on chip
+  #
+  #     returns - byte value
+  #
+  #
+  #     http://www.arduino.cc/playground/Code/I2CEEPROM
+  # ----------------------------------------------------------------------
+  
+  output_pin 19, :as => :mem0, :device => :i2c_eeprom, :enable => :true
+  output_pin 14, :as => :myLCD, :device => :pa_lcd, :rate => 19200
+
+
+    
+  def setup
+      delay 1500        # give startup screen time to finish and clear
+	    myLCD.clearscr    "  I2C EEPROM Demo"
+      myLCD.setxy 0, 1, "byte write then read"
+      myLCD.setxy 0, 2, "  back and display"
+      myLCD.setxy 0, 3, "    to the LCD"
+      
+      clear_off_test
+      myLCD.clearline 1, "  byte write test"
+      
+      myLCD.setxy 0, 2
+      32.upto(109) do				# write address of byte to that b yte
+			  |x| mem0.write_byte  x, x+7
+        myLCD.print(".") if x%2
+        delay 10      # EEPROM write _requires_ 3-10 ms pause
+      end
+
+      clear_off_test
+      myLCD.clearline 1, "  byte read test "
+
+      myLCD.setxy 0, 2
+									# read and print 39 addresses with printable numbers
+      70.upto(105) { |x| myLCD.print(mem0.read_byte(x)) }
+
+      delay 2000
+      clear_off_test
+      myLCD.clearline 1, "-< tests complete >- "
+
+
+  end
+  
+  def loop
+    x = 4       # loop has to have _something_
+  end
+
+
+   def clear_off_test   # clears bottom two lines 
+     delay 2000
+     myLCD.clearline 3
+     myLCD.clearline 2   # leaves you at start of a 
+                              # cleared third line
+   end
+
+end

data/lib/examples/hello_format_print.rb

@@ -0,0 +1,94 @@
+class HelloFormatPrint < ArduinoSketch
+
+  # ----------------------------------------------------------------------
+  #    Demonstrattion of Crude Adaptaion of C Function sprintf()
+  #    to do formatted printing. For now there are some absolutes:
+  #    The write_line method atkes as arguemnst the formatting string
+  #    and the appropriate arguments. It format them to an internal
+  #    buffer sepcified and created when you invoke formatted printing
+  #       formatted_print :as => :line_buf, :buffer_size => 80
+  #    now, to actual do it you use write_line
+  #       write_line "Pies $%02d.%02d", pie_cents/100, pie_cents%100
+  #    then print the string pointed at by string_line
+  #       my_lcd.setxy 3, 2, line_buf 
+  #
+  #      Brian Riley - Underhill Center, VT, USA  Aug 2008
+  #                     <brianbr@wulfden.org>
+  #
+  # ----------------------------------------------------------------------
+
+# demonstrate 4 x 20 pa_lcd toggle between normal and Bignum mode
+# with @toggle external variable thrown in for fun
+
+# change your pins to suit your setup
+  
+  @toggle = "0, int"
+  @pie_cents = "403, int"
+  @pie_price = "7.08"
+
+  
+  input_pin 8,  :as => :button_one, :device => :button
+  input_pin 9,  :as => :button_two, :device => :button
+  input_pin 10, :as => :button_three, :device => :button
+  
+  formatted_print :as => :string_line, :buffer_size => 65   # generally this statement should precede any serial_begin or
+                                                            # LCD display directive
+
+  output_pin 14, :as => :my_lcd, :device => :pa_lcd, :rate => 19200, :clear_screen => :true
+
+  
+  def setup
+    my_lcd.clearscr " --<Press Button>--?nOne, Two, or Three"
+  end
+  
+  def loop 
+    if millis % 500 == 0
+      write_line "millis()= %ld", millis
+      my_lcd.setxy 1, 2, string_line
+    end 
+    say_hello     if button_one.read_input 
+    say_more      if button_two.read_input 
+    say_it_large  if button_three.read_input 
+  end
+  
+  def say_hello
+    @toggle = true
+    my_lcd.clearscr "This sketch has?nbeen running for?n "
+    write_line "%ld mins and %d secs?n", millis/60000, (millis/1000)%60
+    my_lcd.print string_line
+    delay 3000
+    my_lcd.clearscr " --<Press Button>--?nOne, Two, or Three"
+  end
+  
+  def say_more # passing print strings to home and setxy (also works on clearscr)
+    @toggle = false
+    my_lcd.clearscr "Food Store Prices"
+    write_line "Pies $%2d.%02d", @pie_cents/100, @pie_cents%100
+#    write_line "Pies $%6.2f", @pie_price # float doessn't seem to work .....
+    my_lcd.setxy 2, 1, string_line
+#    write_line "toggle state is [%s]", @toggle ? "ON" : "OFF"  # RubyToC screws this construct up and RAD mistajekl put 1 ad 0
+                                                                # in place of "ON" and "OFF"
+    write_line "toggle state is [%d]", @toggle
+    my_lcd.setxy 2, 3, string_line
+    delay 3000
+    my_lcd.clearscr " --<Press Button>--?nOne, Two, or Three"
+  end
+  
+  
+  def say_it_large
+
+    my_lcd.intoBignum
+    my_lcd.clearscr            # line 0, col 0
+    1.upto(32) do |i|
+      my_lcd.setxy 0,1
+      my_lcd.print i * i
+      delay 200
+    end
+    my_lcd.outofBignum
+    delay 3000
+    my_lcd.clearscr " --<Press Button>--?nOne, Two, or Three"      
+  end
+  
+
+ 
+end

data/lib/examples/hello_lcd_charset.rb

@@ -0,0 +1,75 @@
+class HelloLcdCharset < ArduinoSketch
+
+  # -------------------------------------------------------------------------
+  #    Program to Display the entire lower half (under 0x80) character set
+  #
+  #    The class variable @a defined as byte is needed to make RubyToC put
+  #    the value to be 'printed' as a byte and thus give us the character
+  #    that value represents.
+  #
+  #      Brian Riley - Underhill Center, VT, USA  July 2008
+  #                     <brianbr@wulfden.org>
+  #
+  # ----------------------------------------------------------------------
+  
+   
+      @a  = byte
+      
+      output_pin 14, :as => :myLCD, :device => :pa_lcd, :rate => 19200
+      output_pin 13, :as => :led
+
+  def loop
+    
+    myLCD.clearscr  "Alphabet Chars?n"
+    0x41.upto(0x5a) do |i|    # A to Z
+      @a = i                  # forces 'byte' typing to variable
+      myLCD.print @a          # so print rouien prints character represented 
+      delay 50                # by the index value
+    end
+    0x61.upto(0x7a) do |i|    # a to z
+      @a = i
+      myLCD.print @a
+      delay 50
+    end
+    
+    delay 3000
+    myLCD.clearscr  "Numeric Chars?n"
+    0x30.upto(0x39) do |i|    # 0 to 9
+      @a = i
+      myLCD.print @a
+      delay 50
+    end
+    
+    delay 3000
+
+    myLCD.clearscr  "Other Chars?n"
+    0x21.upto(0x2f) do |i|    # punctuation et al
+      @a = i
+      myLCD.print @a
+      delay 50
+    end
+    0x3a.upto(0x40) do |i|
+      @a = i
+      myLCD.print @a
+      delay 50
+    end
+    0x5b.upto(0x60) do |i|
+      @a = i
+      myLCD.print @a
+      delay 50
+    end
+    0x7b.upto(0x7f) do |i|
+      @a = i
+      myLCD.print @a
+      delay 50
+    end
+    
+    delay 3000
+      
+
+
+  end
+  
+  
+  
+end