simatic 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cb39fba52aa7abd65f8a1f837b6a8bb1e5572ffa
+  data.tar.gz: 0e88119b704b2d9c95d6f4744163ac073e5cebc4
+SHA512:
+  metadata.gz: b140bdef40f8ad4a3ffc43ddb4ed828703984fea3c5a5044f40e24dcaa728f63b78c774c55ed006dd7dd2e8ce0a2ebae54485bdd526666d152942f7fbed5efa3
+  data.tar.gz: cac43153f5aebb686b11ed143b9e0edf6d0e052b7138232ec2e70fd48f9dd8e56be2b1337a6cdf9f6834a709bc0a16132fa63cd78baf2ac80ec910ae0b85c290

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in simatic.gemspec
+gemspec

data/README.md

@@ -0,0 +1,91 @@
+# ruby_s7plc
+Ruby library for Siemens Simatic S7-300 PLC data exchange.
+
+## Quick start
+```ruby
+  require 'simatic'
+  Simatic::Plc.exchange('192.168.0.1') do |plc|
+    plc.write('db1.dbw2'=> 0xffff)
+    res = plc.read('db1.dbw2')
+    puts "#{res.verbal} = #{Simatic::Types::Word.parse(res.value)}"
+  end
+```
+
+## Reference
+### Requires
+```ruby
+  require 'simatic'
+```
+
+### Client creation
+```ruby
+  plc = Simatic::Plc.new('192.168.0.1')
+  plc.connect
+  # Add you code here
+  plc.disconnect
+```
+
+Or with block:
+```ruby
+  Simatic::Plc.exchange('192.168.0.1') do |plc|
+    # Add you code here
+  end
+```
+
+You can specify rack and slot parametrs by adding a hash args to functions <new> or <exchange>, defaults rack: 0, slot: 2
+```ruby
+Simatic::Plc.new('192.168.0.1', rack: 0, slot: 2) ...
+Simatic::Plc.exchange('192.168.0.1', rack: 0, slot: 2) do |plc| ...
+```
+
+### Exchange functions
+```ruby
+plc.read('db1.dbx0.0')
+```
+This function can understand verbal adressing in Simatic Step 7 notation, like M0.0, DB1.DBB23, C0, T1 and so on.
+Result of this funtion is a MemoryMapper object that can give you ```raw_data``` and ```value``` of plc response.
+After this function you should use SymaticTypes module to convert data into ruby undestandable types.
+```ruby
+plc.write('db1.dbw2' => 0xffff)
+```
+This function take a hash with verbal addresses and values to write pairs. Values can be simple types like Integer, Float, one char String, Date, Time or it can be special types of SimaticTypes Module.
+```ruby
+plc.write('db1.dbb18[2]'  => Simatic::Types::S5time.new(711.3))
+```
+
+### Convertation functions
+```ruby
+Simatic::Types::Bool   # use TrueClass, FalseClass
+Simatic::Types::Byte   # use Numeric
+Simatic::Types::Word   # use Numeric
+Simatic::Types::Dword  # use Numeric
+Simatic::Types::Int    # use Numeric
+Simatic::Types::Dint   # use Numeric
+Simatic::Types::Real   # use Numeric
+Simatic::Types::S5time # use Numeric as a time in seconds
+Simatic::Types::IECTime     # use Numeric as a time in seconds
+Simatic::Types::IECDate     # use Numeric as a days
+Simatic::Types::TimeOfDay   # use Numeric as a seconds from start of day 0:00 a.m.
+Simatic::Types::DateAndTime # use Time
+Simatic::Types::S7String    # use String with length of buffer param
+```
+Each of this objects take Ruby types with ```new``` method and gives you with ```parse``` method:
+```ruby
+Simatic::Types::S5time.new(10.2)
+Simatic::Types::S5time.parse(res.raw_data)
+Simatic::Types::S7String.new("hello world", 15) # 15 is a length of buffer (address for this string to read or write must be [17])
+```
+For special types like S5time, IECTime, IECDate, TimeOfDay, DateAndTime, S7String you should use ```raw_data``` method instead of `value`, because if you write an adress with [] notation of bytes ```value``` will return a array of chars.
+
+## Waring
+This is beta code! Do not use it in danger manufactory!
+
+## See also
+Father and oldest of all open Simatic communication libraries is Libnodave project:
+  * http://libnodave.sourceforge.net/
+
+Another interesting projects:
+  * https://github.com/kprovost/libs7comm
+  * https://github.com/kirilk/simatic
+  * https://github.com/killnine/s7netplus
+  * https://github.com/plcpeople/nodeS7

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/read

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "simatic"
+
+ip = ARGV.shift
+address = ARGV.shift
+
+type = nil
+slot = 2
+rack = 0
+
+while param = ARGV.shift do
+  case param
+    when '-t', '--type'
+      type = ARGV.shift
+    when '--slot'
+      slot = ARGV.shift
+    when '--rack'
+      rack = ARGV.shift
+    when '-h', '--help'
+      puts "USAGE"
+      puts "read <ip> <address> (-t|--type <type>) [--rack <rack>] [--slot <slot>] [-h|--help]"
+      puts "avaliable types #{Simatic::Types.avaliable}"
+      puts "EXAMPLE"
+      puts "read 192.168.0.1 db0.dbw4 -t int"
+      exit
+  end
+end
+
+#puts "address #{address}"
+#puts "type #{type}"
+#puts "rack #{rack}"
+#puts "slot #{slot}"
+
+Simatic::Plc.exchange(ip, rack: rack, slot: slot) do |plc|
+  value = plc.read(address).value
+  puts "#{address}: #{Simatic::Types.parse value, type}"
+end

data/lib/simatic.rb

@@ -0,0 +1,7 @@
+require 'simatic/types'
+require 'simatic/plc'
+require 'simatic/version'
+
+module Simatic
+  # Your code goes here...
+end

data/lib/simatic/memory_mapper.rb

@@ -0,0 +1,191 @@
+module Simatic
+  class MemoryMapper
+    attr_reader :verbal
+    attr_reader :raw_values
+    attr_accessor :raw_data
+
+    attr_reader :length
+    attr_reader :count
+
+    attr_reader :area
+    attr_reader :db
+    attr_reader :address
+    attr_reader :bit
+
+    def initialize verbal, args={}
+      @verbal = verbal
+
+      parse_address @verbal
+      # puts args[:value]
+      self.value = args[:value] unless args[:value].nil?
+    end
+
+    def parse_address verbal = @verbal
+      /^(DB\s*(?<db>\d+)(\.|\s*))?(?<area>PI|PQ|I|Q|M|DB|T|C)(?<type>X|B|W|D)?\s*?(?<adr>\d+)(\.(?<bit>\d+))?\s*?(\[(?<count>\d+)\])?$/i =~ verbal
+      
+      @db      = db    ? db.to_i    : 0
+      @count   = count ? count.to_i : 1 
+      @address = adr   ? adr.to_i   : nil
+      @bit     = bit   ? bit.to_i   : nil
+
+      unless @address
+        raise "Adressing by #{verbal} is impossible. Cant parse it."
+      end
+
+      case area.upcase
+      when 'PI','PQ'
+        @area = AreaP
+      when 'I'
+        @area = AreaI
+      when 'Q'
+        @area = AreaQ
+      when 'M'
+        @area = AreaM
+      when 'DB'
+        @area = AreaDB
+      when 'T'
+        @area = AreaT
+      when 'C'
+        @area = AreaC
+      end
+
+      case type ? type.upcase : 'X'
+      when 'B'
+        @length = 1
+      when 'W'
+        @length = 2
+      when 'D'
+        @length = 4
+      else
+        @length = 1
+        unless @bit
+          raise "Adressing by #{verbal} is impossible. Cant parse it. Is bit expected?"
+        end
+      end
+    end
+
+    def value= new_value
+      val_array = (new_value.kind_of? Array) ? new_value : [new_value]
+
+      @raw_values = []
+      val_array.each do |v|
+
+        val = case v
+          when Simatic::Types::SimaticType
+            v
+          when Integer
+            case @length
+            when 1
+              Simatic::Types::Byte.new(v)
+            when 2
+              Simatic::Types::Int.new(v)
+            when 4
+              Simatic::Types::Dint.new(v)
+            else
+              raise "Cannot convert #{v.class} to SimaticType class"
+            end
+          when Float
+            Simatic::Types::Real.new(v)
+          when TrueClass, FalseClass
+            Simatic::Types::Bool.new(v)
+          when String
+            raise "Cannot write string to plc use SimaticType::S7String class" if length > 1
+            Simatic::Types::Char.new(v) if v.length == 1
+          when Date
+            Simatic::Types::IECDate.new(v)
+          when Time
+            Simatic::Types::DateAndTime.new(v)
+          else
+            raise "Unknoun type of write value <#{v.class}> #{v}"
+        end
+
+        @raw_values << val.serialize
+      end
+
+      @raw_data = @raw_values.inject { |sum, v| sum+v }
+
+      if @raw_data.length != @length*@count
+        raise "This values #{val_array} can not be writed because adress #{verbal} mean #{@length*@count} byte(s) instead #{@raw_data.length}"
+      end
+    end
+
+    def value
+      @raw_values = []
+
+      byte = 0
+      while byte < @count*@length
+        @raw_values << @raw_data[byte, @length]
+        byte += @length
+      end
+
+      result = @raw_values
+
+      # .map do |raw|
+
+      #   case type
+      #   when :bool
+
+      #     bit = @bit ? 0 : (args[:bit] || nil)
+
+      #     binary_string = raw.unpack('b*').first
+
+      #     if bit
+      #       binary_string[bit] == '1' ? true : false
+      #     else
+      #       binary_string.index('1') ? true : false
+      #     end
+
+      #   when :int8
+      #     raw.unpack('c').first
+      #   when :uint8
+      #     raw.unpack('C').first
+      #   when :int16
+      #     raw.unpack('s>').first
+      #   when :uint16
+      #     raw.unpack('S>').first # try n
+      #   when :int32
+      #     raw.unpack('l>').first
+      #   when :uint32
+      #     raw.unpack('L>').first # try N
+      #   when :float32
+      #     raw.unpack('g').first
+      #   when :float64
+      #     raw.unpack('G').first
+      #   when :text8
+      #     raw.unpack('A*').first
+      #   when :text16
+      #     raw.unpack('u*').first
+      #   else
+      #     raw
+      #   end
+      # end
+
+      result = result.first if result.count == 1
+      result
+    end
+
+    def as_bool raw
+    end
+
+    def as_int raw
+    end
+
+    def as_uint raw
+    end
+
+    def as_real raw_data
+    end
+
+    def as_s5time raw_data
+    end
+
+    def as_time raw_data
+    end
+
+    def as_date raw_data
+    end
+
+    def as_string raw_data
+    end
+  end
+end

data/lib/simatic/plc.rb

@@ -0,0 +1,100 @@
+require 'socket'
+require 'simatic/sessions'
+require 'simatic/memory_mapper'
+
+module Simatic
+  BUFFER_SIZE = 1000
+
+  class Plc
+    def initialize address, args = {}
+      @address = address
+      @rack = args[:rack] || 0
+      @slot = args[:slot] || 2 
+    end
+
+    def self.exchange address, args = {}, timeout = 500
+      plc = self.new address, args
+
+      plc.connect timeout
+      yield plc
+      plc.disconnect
+    end
+
+    def read *args
+      if @socket.nil?
+        raise "Plc #{@address} is not connected"
+      end
+
+      read = Sessions::ReadSession.new
+      memory_mappers = []
+      args.each do |verbal|
+        memory_mappers << MemoryMapper.new(verbal)
+      end
+
+      request = read.make_request memory_mappers
+      @socket.send request, 0
+
+      # debug_print request
+
+      response =  @socket.recv BUFFER_SIZE
+
+      # debug_print response
+
+      result = read.parse_response response
+
+      # Hash[result.map { |memory_mapper| [memory.verbal, memory.value] }]
+    end
+
+    def write args
+      if @socket.nil?
+        raise "Plc #{@address} is not connected"
+      end
+
+      memory_mappers = []
+      args.each do |verbal, value|
+        memory_mappers << MemoryMapper.new(verbal, value: value)
+      end
+
+      write = Sessions::WriteSession.new
+      request = write.make_request memory_mappers
+      @socket.send request, 0
+
+      # debug_print request
+
+      response =  @socket.recv BUFFER_SIZE
+
+      # debug_print response
+
+      result = write.parse_response response
+    end
+    
+    def connect timeout = 500
+      @socket = Socket.tcp @address, 102, connect_timeout: timeout / 1000.0
+
+      setup = Sessions::SetupSession.new @rack, @slot
+      @socket.send setup.make_request, 0
+      setup.parse_response @socket.recv BUFFER_SIZE
+
+      open = Sessions::OpenSession.new
+      @socket.send open.make_request, 0
+      open.parse_response @socket.recv BUFFER_SIZE
+
+    end
+
+    def disconnect
+      @socket.close
+    end
+
+    private
+
+    def debug_print raw
+      puts '-'*80
+      raw.bytes.each_with_index do |byte, i|
+        ends = (i+1)%16 == 0 ? "\n" : ' '
+        printf '%02X '+ ends, byte
+      end
+      puts ''
+      puts '-'*80
+    end
+  end
+end