intel_hex 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 84c4297419b1ccfc1e823f6a20c501214edde2a36ac39fe99f1160878ef55f98
+  data.tar.gz: 8d2b0689beaa411af37370cdfa389b386cc4b44d05b7851ff3165f5ddcd546c4
+SHA512:
+  metadata.gz: f983e15e9e06d56517b3101bef8580807c2221a7dbd24252c4de2784996803db5b6015aa2e4634334514024e61bdb63f69f33e7b6a168408ae27eb7223323536
+  data.tar.gz: 96208bdfed373003d8ba309af7017ec7065519bf9a638fa3b8b7e56977617ee2a1390686b00730f103fc4b6468159a193d32d10412d2b1707fceebf69b8cd12b

data/LICENSE.md

@@ -0,0 +1,28 @@
+This software is licensed under the Revised (3-clause) BSD license as follows:
+
+Copyright (c) 2019, Jeremy Cole <jeremy@jcole.us>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of the <organization> nor the
+  names of its contributors may be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,3 @@
+# An Intel hex file parser, for Ruby
+
+See the [Wikipedia page on Intel HEX](https://en.wikipedia.org/wiki/Intel_HEX).

data/bin/intel_hex_reader

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'intel_hex'
+require 'pp'
+
+@options = {
+  file: nil,
+}
+
+OptionParser.new do |opts|
+  opts.on('--help', 'Print this help.') { puts; puts opts; puts; exit }
+  opts.on('-f', '--filename=FILE', 'Load the specified file.') { |o| @options[:file] = o }
+end.parse!
+
+raise "No file specified" unless @options[:file]
+
+intel_hex_file = IntelHex::FileReader.new(@options[:file])
+
+intel_hex_file.each_record do |record|
+  case record.type
+  when :data
+    record_data = "data=" + record.data.map { |b| "%02x" % b }.join(" ")
+  when :eof
+    record_data = ""
+  else
+    record_data = "value=" + record.send(data.type)
+  end    
+
+  puts "Record type=%-4s offset=%-4d length=%-4d checksum=%-4d %s" % [
+    record.type,
+    record.offset,
+    record.length,
+    record.checksum,
+    record_data,
+  ]
+end
+

data/lib/intel_hex.rb

@@ -0,0 +1,6 @@
+module IntelHex
+end
+
+require 'intel_hex/version'
+require 'intel_hex/record'
+require 'intel_hex/file_reader'

data/lib/intel_hex/file_reader.rb

@@ -0,0 +1,52 @@
+module IntelHex
+  class FileReader
+    def initialize(filename)
+      @filename = filename
+      @address_base = 0
+      @address_mask = 0xffff
+      @esa = 0
+      @ssa = 0
+      @ela = 0
+      @sla = 0
+    end
+
+    def each_record
+      return to_enum(:each_record) unless block_given?
+  
+      file = File.open(@filename, 'r')
+
+      begin
+        file.each_line do |line|
+          yield Record.parse(line.chomp)
+        end
+      rescue EOFError
+        return nil
+      end
+
+      nil
+    end
+  
+    def each_byte_with_address
+      return to_enum(:each_byte_with_address) unless block_given?
+  
+      each_record do |record|
+        case record.type
+        when :data
+          record.each_byte_with_address do |byte, offset|
+            yield byte, (@address_base + offset) & @address_mask
+          end
+        when :esa
+          @esa = record.esa
+          @address_base = @esa << 4   # bits 4..19 of address
+          @address_mask = 0xfffff     # 20 bit address size
+        when :ela
+          @ela = record.ela
+          @address_base = @ela << 16  # bits 16..31 of address
+          @address_mask = 0xffffffff  # 32 bit address size
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/intel_hex/record.rb

@@ -0,0 +1,228 @@
+module IntelHex
+  class MisformattedFileError < RuntimeError; end
+  class InvalidTypeError < RuntimeError; end
+  class InvalidLengthError < RuntimeError; end
+  class InvalidOffsetError < RuntimeError; end
+  class InvalidDataError < RuntimeError; end
+  class InvalidChecksumError < RuntimeError; end
+
+  class Record
+    TYPES = [
+      :data,
+      :eof,
+      :esa,
+      :ssa,
+      :ela,
+      :sla,
+    ]
+
+    TYPE_MAP = TYPES.each_with_index.inject({}) { |h, (k, i)| h[k] = i; h }
+  
+    TYPE_DATA_LENGTH = {
+      data: (1..255),
+      eof: 0,
+      esa: 2,
+      ssa: 2,
+      ela: 2,
+      sla: 4,
+    }
+
+    def self.parse(line)
+      raise MisformattedFileError.new("Expected ':' at start of line") unless line[0] == ':'
+      raise MisformattedFileError.new("Line length incorrect") unless line.size >= (1 + 2 + 4 + 2)
+
+      length = line[1..2].to_i(16)
+      data_end = (9 + length*2)
+
+      offset = line[3..6].to_i(16)
+      type = TYPES[line[7..8].to_i(16)]
+      data = line[9...data_end].split('').each_slice(2).map { |a| a.join.to_i(16) }
+      checksum = line[data_end..(data_end + 2)].to_i(16)
+
+      Record.new(type, length, offset, data, checksum, line: line, validate: true)
+    end
+
+    def self.data(data)
+      record = Record.new(:data)
+      record.data = data
+      record
+    end
+
+    def self.eof
+      Record.new(:eof)
+    end
+
+    def self.type_with_value(type, value)
+      record = Record.new(type)
+      record.send((type.to_s + '=').to_sym, value)
+      record
+    end
+
+    def self.esa(value)
+      type_with_value(:esa, value)
+    end
+
+    def self.ssa(value)
+      type_with_value(:ssa, value)
+    end
+
+    def self.ela(value)
+      type_with_value(:ela, value)
+    end
+
+    def self.sla(value)
+      type_with_value(:sla, value)
+    end
+
+    attr_reader :length
+    attr_reader :offset
+    attr_reader :type
+    attr_reader :data
+    attr_reader :checksum
+    attr_reader :line
+
+    def initialize(type, length = 0, offset = 0, data = [], checksum=nil, line: nil, validate: false)
+      @type = type
+      @length = length
+      @offset = offset
+      @data = data
+      @calculated_checksum = nil
+      @checksum = checksum || calculate_checksum
+      @line = line
+
+      self.validate if validate
+    end
+
+    def to_s
+      "#<#{self.class.name} type=#{type} offset=#{offset} length=#{length}>"
+    end
+
+    def to_ascii
+      ":%02X%04X%02X%s%02X" % [
+        length,
+        offset,
+        TYPE_MAP[type],
+        data.map { |b| "%02X" % b }.join,
+        checksum,
+      ]
+    end
+
+    def calculate_checksum
+      return @calculated_checksum if @calculated_checksum
+
+      sum = length + ((offset & 0xff00) >> 8) + (offset & 0x00ff) + TYPE_MAP[type]
+      sum += data.inject(0) { |s, n| s += n; s }
+
+      @calculated_checksum = (((sum & 0xff) ^ 0xff) + 1) & 0xff
+    end
+
+    def recalculate_checksum
+      @calculated_checksum = nil
+      calculate_checksum
+    end
+
+    def valid?
+      begin
+        validate
+        return true
+      rescue
+        return false
+      end
+    end
+
+    def validate
+      validate_type
+      validate_length
+      validate_offset
+      validate_data
+      validate_checksum
+    end
+
+    def validate_type
+      raise InvalidTypeError.new("Type #{type} is invalid") unless TYPE_MAP.include?(type)
+    end
+
+    def validate_offset
+      raise InvalidOffsetError.new("Offset #{offset} is negative") unless offset >= 0
+      raise InvalidOffsetError.new("Offset #{offset} is too large") unless offset <= 255
+    end
+
+    def validate_length
+      valid_length = TYPE_DATA_LENGTH[type]
+
+      case valid_length
+      when Integer
+        return if length == valid_length
+      when Range
+        return if valid_length.include?(length)
+      end
+
+      raise InvalidLengthError.new("Length for type #{type} must be #{valid_length}; #{length} given") 
+    end
+
+    def validate_data
+      raise InvalidDataError.new("Data length #{data.size} does not match length #{length}") unless data.size == length
+    end
+
+    def validate_checksum
+      raise InvalidChecksumError.new("Checksum value #{checksum} does not match expected checksum #{calculate_checksum}") unless calculate_checksum == checksum
+    end
+
+    def each_byte_with_address
+      return Enumerator.new(self, :each_byte_with_address) unless block_given?
+  
+      data.each_with_index do |byte, i|
+        yield byte, offset + i
+      end
+
+      nil
+    end
+
+    def data=(value)
+      raise "Incorrect data type" unless value.is_a?(Array)
+      raise InvalidLengthError.new("Data length #{value.size} too large") unless value.size <= 255
+      @data = value
+      @length = data.size
+      @checksum = recalculate_checksum
+      nil
+    end
+
+    def data_to_uint16(offset = 0)
+      (data[offset + 0] << 8) | data[offset + 1]
+    end
+
+    def uint16_to_data(value, offset = 0)
+      self.data[(offset...(offset+2))] = [
+        (value & 0xff00) >> 8,
+        value & 0x00ff
+      ]
+      @length = data.size
+      @checksum = recalculate_checksum
+    end
+
+    def data_to_uint32(offset = 0)
+      (data[offset + 0] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3]
+    end
+
+    def uint32_to_data(value, offset = 0)
+      self.data[(offset...(offset+4))] = [
+        (value & 0xff000000) >> 24,
+        (value & 0x00ff0000) >> 16,
+        (value & 0x0000ff00) >> 8,
+        value & 0x000000ff
+      ]
+      @length = data.size
+      @checksum = recalculate_checksum
+    end
+
+    alias_method :esa, :data_to_uint16
+    alias_method :ssa, :data_to_uint16
+    alias_method :ela, :data_to_uint16
+    alias_method :sla, :data_to_uint32
+
+    alias_method :esa=, :uint16_to_data
+    alias_method :ssa=, :uint16_to_data
+    alias_method :ela=, :uint16_to_data
+    alias_method :sla=, :uint32_to_data
+  end
+end

data/lib/intel_hex/version.rb

@@ -0,0 +1,3 @@
+module IntelHex
+  VERSION = '0.5.0'
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: intel_hex
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Jeremy Cole
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-04 00:00:00.000000000 Z
+dependencies: []
+description: An Intel hex file parser for (e.g. AVR) working with firmware files
+email: jeremy@jcole.us
+executables:
+- intel_hex_reader
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- bin/intel_hex_reader
+- lib/intel_hex.rb
+- lib/intel_hex/file_reader.rb
+- lib/intel_hex/record.rb
+- lib/intel_hex/version.rb
+homepage: https://github.com/jeremycole/intel_hex
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Parser for Intel hex files
+test_files: []