micro_aeth-ae51-ruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d6c48744a043423d468f6efbe381db6ed005d668
+  data.tar.gz: 992247eaeb80568221f19142cc0a0b3f8448417d
+SHA512:
+  metadata.gz: a49064b2b7c4ef853ce5eb51ce359ae3f1ebc9895205045e577f47986c72d2bb019d5e042d7f30ad91da2b2d7957d4ed0e162ede8af6a06b274b386837562dfa
+  data.tar.gz: e90dc640e49fa5f117ffa001c100db896a39bcfc2e31a642fd73c5bc13ec3d75733703c5cf59a31f2788750f443540eff9f7e1cdccc54d9e034fbaf43c6b1bee

data/lib/micro_aeth-ae51.rb

@@ -0,0 +1,317 @@
+require 'serialport'
+require 'timeout'
+
+module MicroAethAE51
+  class ::String
+    ###
+    # @return the first charater in the string as an integer
+    def byte
+      self.bytes[0]
+    end
+
+    ### 
+    # XOR two strings
+    # @str assumed to be a one byte string or integer
+    def ^ str
+      if str.class == String
+        str = str.byte
+      elsif str.class == Fixnum
+        nil
+      else
+        raise "invalid arg: #{str.class} \n Must be String or Fixnum"
+      end
+      self.bytes.each do |i|
+        str = str ^ i
+      end
+      str.chr.force_encoding( "ASCII-8BIT")
+    end
+  end
+
+  class Instruction
+    ###
+    # Message constants
+    STX = "\x02" # Start of each message
+    ETX = "\x03" # End of each message
+    M = "AE5X:" # What each message starts with
+    EraseFlash = "E" # Reply:ACK, after flash is erased anotherACK issent.(erasing should take 30 – 45 seconds)
+    StopWrite = "S" # stopswriting to flash
+    StartWrite = "W" # Startswriting to flash
+    Kill = "K" # Kill Shuts down microAeth
+  end
+
+  ###
+  # Creates and parses messages to and from the MicroAeth.
+  # See MicroAeth::Com for specifications on the
+  # transmiting of messages.
+  class Message
+    attr :original_char_string,
+         :ref,
+         :sen1,
+         :sen2,
+         :flow,
+         :pcb_temp,
+         :time,
+         :status,
+         :battery
+
+    ###
+    # @param data [String] conents between the `STX` "\x02"
+    #   and the `ETX` "0x03"
+    def initialize data
+      raise "invalid data" unless data_valid? data
+      @original_char_string = data
+      parse_data( data[7..-1])
+    end
+
+    private
+      def data_valid? d
+        crc = d[-1]
+        data = d[1..-2]
+        len = d[0]
+        (data ^ len).byte == crc.byte
+      end
+      def parse_data d
+        b = d.bytes
+        @ref = d[0..2].unpack("v")[0]
+        @sen1 = d[3..5].unpack("v")[0]
+        @sen2 = d[6..8].unpack("v")[0]
+        @flow = d[9..10].unpack("v")[0]
+        @pcb_temp = b[11]
+        @time = Time.new ('20' + b[12].to_s).to_i,
+                         b[13],
+                         b[14],
+                         b[15],
+                         b[16],
+                         b[17]
+        @status = b[18]
+        @battery = d[19..20].unpack("v")[0]
+      end
+  end
+
+
+  ##
+  # Initializes a link between the the system and the device.
+  # used to transmit and recieive MicroAeth::Message
+  # 
+  class Com
+    attr_accessor :com, :messages
+    attr_reader :com_thread
+
+    def initialize
+      port     = '/dev/serial/by-id/usb-AethLabs_microAeth_Model_AE51_AE51-S4-649-1303-if00-port0'
+      baud     = 500_000
+      bytesize = 8
+      stopbits = 1
+      parity   = SerialPort::MARK
+      @com     = SerialPort.new port, baud, bytesize, stopbits, parity
+      @messages = []
+    end
+
+    ###
+    # @m The message to be written
+    def write instruction
+      data = MicroAeth::Instruction::M + instruction
+      len = data.length.chr
+      crc = data ^ len
+      @com.write (MicroAeth::Instruction::STX + len + data + crc + MicroAeth::Instruction::ETX).force_encoding("ASCII-8BIT")
+    end
+
+    def erase_flash
+      begin 
+        clear_buffer
+        write MicroAeth::Instruction::EraseFlash
+        Timeout::timeout(60) { wait_for_acknowledge }
+        sleep 45
+        Timeout::timeout(60) { wait_for_acknowledge }
+        write MicroAeth::Instruction::StartWrite
+        Timeout::timeout(60) { wait_for_acknowledge }
+      rescue Timeout::Error
+        retry
+      end 
+    end
+    def clear_buffer
+      begin
+        while true 
+          Timeout::timeout(0.5) { read_message }
+        end
+      rescue Timeout::Error
+        nil
+      end
+    end
+
+    def wait_for_acknowledge
+      while read_message != "\u0006AE5X:A\u0014".force_encoding("ASCII-8BIT")
+        nil
+      end
+    end
+
+    def start
+      puts "The MicroAeth is starting!.."
+      begin 
+        clear_buffer
+      rescue [EOFError, Timeout::Error]
+        raise "Problem stating the MicroAeth"
+      end
+    end
+
+    ##
+    # @return A ruby thread which continually reads
+    #   from the MicroAeth::Com#com instance
+    def read
+      @com_thread = Thread.new do
+        begin
+          while true
+            @messages << ( Message.new read_message )
+          end
+        # Intermitently, it the serialport library raises end of file...
+        rescue EOFError
+          sleep 1
+          retry
+        end 
+      end
+    end
+    
+    ###
+    # @file a ruby file object
+    def start_write_to_file file_name
+      @stop_writing_to_file = false
+      @thread = Thread.new do
+        clear_buffer
+        m_prev = nil
+        while @stop_writing_to_file != true
+          begin
+            m = Message.new read_message
+          rescue RuntimeError
+            retry
+          end
+          erase_flash if m.status == 64
+          atn = Math.log( m.ref.to_f / m.sen1.to_f) * 100
+          file = File.new file_name, 'a'
+          print message = [Time.now, m.ref, m.sen1, atn, m.flow, m.pcb_temp, m.status, m.battery, sigma_ap( m, m_prev)].join(',') + "\n"
+          file << message
+          file.close
+          m_prev = m
+        end
+      end
+    end
+    def stop_write_to_file
+      @stop_writing_to_file = true
+      @thread.join 30
+    end
+
+    def sigma_ap m, m_prev
+      if m_prev.nil? 
+        "NaN" 
+      else 
+        Math::PI * (0.3 ** 2) / 4.0 / m.flow.to_f * 60.0 * 
+          Math.log( m_prev.sen1.to_f / m.sen1.to_f * m.ref.to_f / m_prev.ref.to_f) * (10.0 ** 8)
+      end
+    end
+    def read_message
+      m, c = '',''
+      while c != "\x02"; c = @com.readchar; end
+      c = @com.readchar
+      m << c
+      len = c.byte
+      0.upto len do |i|
+        c = @com.readchar
+        m << c
+      end
+      while c != "\x03"
+        c = @com.readchar
+        m << c
+      end
+      m[0..-2]
+    end
+  end
+end
+
+=begin
+You'll need to assemble a properly formed message, or it won't respond.   
+## Properly forming a messages as suggested by Karl Walter
+
+Communication protocol is based on folowing syntax: 
+`STX LEN DATA CRC ETX`  where:
+
+* `STX` is one byte 0x02 (HEX values)
+* `LEN` is one byte lenght of `DATA` 
+* `CRC` is XOR function between `LEN` byte and `DATA` bytes 
+  * I'm assuming this is the last byte of data
+* `ETX` is one byte 0x03
+
+Every string of `DATA` that microAethCOM PC 
+software sends starts with `AE5X:` followed by one letter. 
+
+So you need to write some code to take the data you 
+want to send it, add the `STX` (`0x02`), calculate the 
+`LEN` and add it, Calculate the `CRC`, add that, then finally 
+add the `ETX` (`0x03`).
+
+The `CRC` is always the hardest to get to work.  
+`CRC` is `XOR` function between `LEN` byte and `DATA` bytes.  
+http://en.wikipedia.org/wiki/Bitwise_operation#XOR 
+You'll probably have to make a best guess as how to `XOR` the `DATA` and `LEN`,
+then try it on the messages that the MicroAeth sends, and see if you get the
+`CRC` that it produced.  
+
+The `LEN` in the messages  from it seemed like they where one longer than the
+number of data bytes, so you'll have to experiment with that.
+
+Also the `LEN` is only 1 byte, and the `DATA` can be any number, so I think you
+are  suppose to `XOR` the `LEN` with the first `DATA` byte, then take that and
+XOR with the second, and so on, sort of like Xmodem.  I'm not sure which is the
+first `DATA` byte, though.
+
+This may help: http://crcmod.sourceforge.net/crcmod.html
+
+Also just google for `XOR CRC`, finds some good stuff like
+[this](http://stackoverflow.com/questions/344961/how-do-you-compute-the-xor-remainder-used-in-crc)
+
+You should also make sure that when you send /x02 that it sends 00000010 not
+
+01011100 01111000 00110000 00110010.
+
+  # from http://aethlabs.com/sites/all/content/microaeth/microAeth%20Model%20AE51%20Operating%20Manual.pdf
+  - Data(index)
+  - Data(index+1)
+  - Data(index+2)
+  - ‘Sen1
+  - Data(index+3)
+  - Data(index+4)
+  - Data(index+5)
+  - ‘Sen2
+  - Data(index+6)
+  - Data(index+7)
+  - Data(index+8)
+  - ‘Flow
+  - Data(index+9)
+  - Data(index+10)
+  - ‘PCBTemp
+  - Data(index+11)
+  - ‘Date
+  - Data(index+12)
+  - Data(index+13)
+  - Data(index+14)
+  - ‘Time
+  - Data(index+15)
+  - Data(index+16)
+  - Data(index+17)
+  - ‘Status
+  - Data(index+18)
+  - ‘Battery
+  - Data(index+19)
+  - Data(index+20)
+  - ‘Reserved forGPS etc...
+  - Data(index+21)
+  - Data(index+22)
+  - Data(index+23)
+  - Data(index+24)
+  - Data(index+25)
+  - Data(index+26)
+  - Data(index+27)
+  - Data(index+28)
+  - Data(index+29)
+  - Data(index+30) 
+
+Acknowledge: "\u0006AE5X:A\u0014" 
+=end

data/lib/micro_aeth-ae51/version.rb

@@ -0,0 +1,8 @@
+module MicroAethAE51
+    major = 0
+    minor = 0
+    tiny  = 1
+    #pre   = ""
+
+    VERSION = [major, minor, tiny].compact.join('.')
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: micro_aeth-ae51-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kurt R. Rudolph
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: serialport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: This Gem provides and easy to use API for sending and receiving data
+  and commands for the microAeth model AE51. This library is not complete but encompasses
+  the most common commands for interfacing with the device.
+email:
+- kurt@rudycomputing.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/micro_aeth-ae51/version.rb
+- lib/micro_aeth-ae51.rb
+homepage: https://github.com/RudyComputing/microAeth-AE51-Ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- a microAeth model AE51
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby API for AethLabs microAeth® model AE51
+test_files: []
+has_rdoc: