serial_modem 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f4ad510a17d04cf960fbb07b9fee8da5e3a705d
+  data.tar.gz: c561195ce7439aa7a25214caeb3f4ead70ba227c
+SHA512:
+  metadata.gz: edee72d6fff2ebd4f98b2a887c45a09a4c2c2f6ae0fab8b6773450bf187cf3615c0710037190efe30e71970a2427f273c3d0e6d71f929c2de4e2f497181499fe
+  data.tar.gz: b0ca14f55324f823432c626178af5bea5680a5758022d98c99213dc8d4f98d52b28dfd39529f50618d78e87850b0daee7f9fbd65648d21b638949b7633fbfd95

data/.gitignore

@@ -0,0 +1,17 @@
+/.hg/
+/.hgignore
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/.idea/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,3 @@
+Copyright (c) 2015 Linus Gasser
+
+GPLv3 or later at your convenience

data/README.md

@@ -0,0 +1,139 @@
+# SerialModem
+
+Simple interface for Serial Modems. Tested:
+- Huawei E303 in serial mode
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'SerialModem'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install SerialModem
+
+## Usage
+
+### Simple
+
+If everything is connected and the modem is recognized (/dev/ttyUSB* is
+ available), then you can simply do:
+
+```
+require 'serialmodem'
+
+SerialModem::setup_modem
+return unless SerialModem.attached?
+
+SerialModem::ussd_send('*100#')
+SerialModem::sms_send('+23599999999', 'Hello from SerialModem')
+```
+
+### Ussd
+
+Huawei-modems with Hilink don't support USSD, so you have to switch them
+to serial-mode. Older modems (pre-2015) are handled with _HilinkModem_, newer versions
+not yet. Once the modem is in serial-mode, you can send and receive USSD-codes.
+It is even possible to use USSD-menus.
+
+#### Sending
+
+Supposing the modem is setup, you can do
+
+```
+SerialModem::send_ussd('*100#')
+```
+
+Or, if you need a menu where each step needs an answer, you can do
+
+```
+SerialModem::send_ussd('*800#', '1', '2', '1234')
+```
+
+Now each command waits for the last command to be completed.
+
+#### Receiving
+
+The received codes are stored in an array of hashes, where each hash has
+three fields:
+
+  - time: a string of "%H:%M"
+  - code: the ussd-code as sent out by 'ussd_send'
+  - result
+
+There is a maximum of _SerialModem::serial_ussd_results_max_ messages
+stored.
+
+```
+SerialModem::send_ussd('*128#')
+sleep 10
+result = SerialModem.serial_ussd_results.first.result
+```
+
+#### Asynchronous receiving
+
+You can also define a listener in _SerialModem.serial_ussd_new_
+
+### SMS
+
+Similar to USSD, you can send and receive SMS. Due to some restrictions in
+Huawei-modems, there is a thread that checks for new SMSs every 20s. Normally
+modems should reply as soon as an SMS is received, but most of the Huawei-modems
+tested delete SMS automatically when in this mode. If you prefer nonethelss to
+rely on this mode, set _SerialModem.serial_sms_autoscan_ to 0.
+
+#### Sending
+
+If everything is recognized, simply do:
+
+```
+SerialModem.sms_send('+23599999999', 'Hello from SerialModem')
+```
+
+And the message should be sent.
+
+#### Receiving
+
+All SMS are put in a hash of arrays with the key of the hash being the message-id
+ and the elements of the array as follows:
+
+0: sms-flag
+1: number of sender
+2: unknown field
+3: date and time of SMS
+4: the message
+
+#### Asynchronous receiving
+
+You can also use the _SerialModem.serial_sms_new_ variable to set up an
+automatic callback whenever a new SMS is received:
+
+```
+
+def treat_sms(list, id)
+  p "Received SMS from #{list[id][1]}"
+end
+
+SerialModem.serial_sms_new.push(Proc.new { |list, id| treat_sms(list, id) })
+
+# Wait for SMS
+```
+
+## Special
+
+Some care has been taken that the serial modem is recognized and can be
+functional again in case of error:
+
+### detach and re-attach in case of power-failure
+
+It can happen that the modem is in use and is reattached because of errors in the
+power. In that case it is not attached anymore to '/dev/ttyUSB2', but to
+'/dev/ttyUSB3'. With some luck, the _SerialModem.reload_option_ can help to
+make things OK again.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+

data/commit

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+git_func(){
+  if [ "$( which git 2>/dev/null )" ]; then
+    git "$@"
+  fi
+}
+
+if [ ! "$1" ]; then
+  hg diff
+  hg st
+  git_func status
+  echo
+else
+  hg commit -m "$@"
+  git_func commit -a -m "$@"
+fi

data/lib/serial_modem.rb

@@ -0,0 +1,418 @@
+require 'serialport'
+require 'helperclasses'
+
+module SerialModem
+  DEBUG_LVL = 1
+  attr_accessor :serial_sms_new, :serial_sms,
+                :serial_ussd_new
+  extend self
+  include HelperClasses
+  include HelperClasses::DPuts
+  extend HelperClasses::DPuts
+
+  def setup_modem(dev = nil)
+    @serial_debug = false
+    @serial_tty = @serial_tty_error = @serial_sp = nil
+    @serial_replies = []
+    @serial_codes = {}
+    @serial_sms = {}
+    # TODO: once serialmodem == class, change this into Observer
+    @serial_sms_new = []
+    @serial_sms_autoscan = 20
+    @serial_sms_autoscan_last = Time.now
+    @serial_ussd = []
+    @serial_ussd_last = Time.now
+    @serial_ussd_timeout = 30
+    @serial_ussd_results = []
+    @serial_ussd_results_max = 100
+    # TODO: once serialmodem == class, change this into Observer
+    @serial_ussd_new = []
+    @serial_mutex_rcv = Mutex.new
+    @serial_mutex_send = Mutex.new
+    # Some Huawei-modems eat SMS once they send a +CMTI-message - this
+    # turns off the CMTI-messages which slows down incoming SMS detection
+    @serial_eats_sms = false
+    setup_tty
+  end
+
+  def read_reply(wait = nil)
+    @serial_debug and dputs_func
+    raise IOError.new('NoModemHere') unless @serial_sp
+    ret = []
+    begin
+      @serial_mutex_rcv.synchronize {
+        while !@serial_sp.eof? || wait
+          begin
+            @serial_replies.push rep = @serial_sp.readline.chomp
+            break if rep == wait
+          rescue EOFError => e
+            dputs(4) { 'Waited for string, but got nothing' }
+            break
+          end
+        end
+      }
+
+      while m = @serial_replies.shift
+        @serial_debug and dputs_func
+        next if (m == '' || m =~ /^\^/)
+        dputs(3) { "Reply: #{m}" }
+        ret.push m
+        if m =~ /\+[\w]{4}: /
+          code, msg = m[1..4], m[7..-1]
+          dputs(3) { "found code #{code.inspect} - #{msg.inspect}" }
+          @serial_codes[code] = msg
+          case code
+            when /CMGL/
+              # Typical input from the modem:
+              # "0,\"REC UNREAD\",\"+23599836457\",,\"15/04/08,17:12:21+04\""
+              # Output desired:
+              # ["0", "REC UNREAD", "+23599836457", "", "15/04/08,17:12:21+04"]
+              id, flag, number, unknown, date =
+                  msg.scan(/"(.*?)"|([^",]+)\s*|,,/).collect { |a, b| a.to_s + b.to_s }
+              ret.push @serial_replies.shift
+              sms_new(id, flag, number, date, ret.last, unknown)
+            when /CUSD/
+              if pdu = msg.match(/.*\"(.*)\".*/)
+                ussd_received(pdu_to_ussd(pdu[1]))
+              elsif msg == '2'
+                #log_msg :serialmodem, 'Closed USSD.'
+                #ussd_received('')
+                #ussd_close
+              else
+                log_msg :serialmodem, "Unknown: CUSD - #{msg}"
+              end
+            when /CMTI/
+              if msg =~ /^.ME.,/
+                dputs(3) { "I think I got a new message: #{msg}" }
+                sms_scan true
+              else
+                log_msg :serialmodem, "Unknown: CMTI - #{msg}"
+              end
+              @serial_eats_sms and modem_send('AT+CNMI=0,0,0,0,0', 'OK')
+            # Probably a message or so - '+CMTI: "ME",0' is a new message
+          end
+        end
+      end
+    rescue IOError => e
+      raise e
+=begin
+    rescue Exception => e
+      puts "#{e.inspect}"
+      puts "#{e.to_s}"
+      puts e.backtrace
+=end
+    end
+    ret
+  end
+
+  def sms_new(id, flag, number, date, msg, unknown = nil)
+    sms = {flag: flag, number: number, unknown: unknown, date: date,
+           msg: msg, id: id}
+    @serial_sms[id.to_s] = sms
+    if flag =~ /unread/i
+      log_msg :SerialModem, "New SMS: #{sms.inspect}"
+      rescue_all do
+        @serial_sms_new.each { |s|
+          s.call(sms)
+        }
+      end
+    end
+    sms
+  end
+
+  def modem_send(str, reply = true)
+    return unless @serial_sp
+    @serial_debug and dputs_func
+    dputs(3) { "Sending string #{str} to modem" }
+    @serial_mutex_send.synchronize {
+      begin
+        @serial_sp.write("#{str}\r\n")
+      rescue Errno::EIO => e
+        log_msg :SerialModem, "Couldn't write to device"
+        kill
+        return
+      rescue Errno::ENODEV => e
+        log_msg :SerialModem, 'Device is not here anymore'
+        kill
+        return
+      end
+    }
+    read_reply(reply)
+  end
+
+  def switch_to_hilink
+    modem_send('AT^U2DIAG=119', 'OK')
+  end
+
+  def save_modem
+    modem_send('AT^U2DIAG=0', 'OK')
+  end
+
+  def ussd_to_pdu(str)
+    str.unpack('b*').join.scan(/.{8}/).map { |s| s[0..6] }.join.
+        scan(/.{1,8}/).map { |s| [s].pack('b*').unpack('H*')[0].upcase }.join
+  end
+
+  def pdu_to_ussd(str)
+    [str].pack('H*').unpack('b*').join.scan(/.{7}/).
+        map { |s| [s+"0"].pack('b*') }.join
+  end
+
+  def ussd_send_now
+    return unless @serial_ussd.length > 0
+    str_send = @serial_ussd.first
+    @serial_ussd_last = Time.now
+    if str_send
+      #log_msg :SerialModem, "Sending ussd-string #{str_send} with add of #{@ussd_add} "+
+                              "and queue #{@serial_ussd}"
+      modem_send("AT+CUSD=1,\"#{ussd_to_pdu(str_send)}\"#{@ussd_add}", 'OK')
+    else
+      dputs(2) { 'Sending ussd-close' }
+      @serial_ussd.shift
+      ussd_close
+    end
+  end
+
+  def ussd_close
+    modem_send("AT+CUSD=2#{@ussd_add}", 'OK')
+    @serial_ussd.length > 0 and ussd_send_now
+  end
+
+  def ussd_send(str)
+    if str.class == String
+      dputs(3) { "Sending ussd-code #{str}" }
+      @serial_ussd.push str
+      @serial_ussd.length == 1 and ussd_send_now
+    elsif str.class == Array
+      dputs(3) { "Sending menu-command #{str}" }
+      @serial_ussd.concat str
+      @serial_ussd.push nil
+      @serial_ussd.length == str.length + 1 and ussd_send_now
+    end
+  end
+
+  def ussd_store_result(str)
+    if @serial_ussd.length > 0
+      code = @serial_ussd.shift
+      dputs(2) { "Got USSD-reply for #{code}: #{str}" }
+      @serial_ussd_results.push(time: Time.now.strftime('%H:%M'),
+                                code: code, result: str)
+      @serial_ussd_results.shift([0, @serial_ussd_results.length -
+                                       @serial_ussd_results_max].max)
+      ussd_send_now
+      code
+    else
+      #log_msg :serialmodem, "Got unasked code #{str}"
+      'unknown'
+    end
+  end
+
+  def ussd_received(str)
+    code = ussd_store_result(str)
+    dputs(2) { "Got result for #{code}: -#{str}-" }
+    @serial_ussd_new.each { |s|
+      s.call(code, str)
+    }
+  end
+
+  def ussd_fetch(str)
+    return nil unless @serial_ussd_results
+    dputs(3) { "Fetching str #{str} - #{@serial_ussd_results.inspect}" }
+    res = @serial_ussd_results.reverse.find { |u| u._code == str }
+    res ? res._result : nil
+  end
+
+  def sms_send(number, msg)
+    log_msg :SerialModem, "Sending SMS --#{msg.inspect}-- to --#{number.inspect}--"
+    modem_send('AT+CMGF=1', 'OK')
+    modem_send("AT+CMGS=\"#{number}\"")
+    modem_send("#{msg}\x1a", 'OK')
+  end
+
+  def sms_scan(force = false)
+    if force || (@serial_sms_autoscan > 0 &&
+        Time.now - @serial_sms_autoscan_last > @serial_sms_autoscan)
+      dputs(3) { 'Auto-scanning sms' }
+      @serial_sms_autoscan_last = Time.now
+      modem_send('AT+CMGF=1', 'OK')
+      modem_send('AT+CMGL="ALL"', 'OK')
+    end
+  end
+
+  def sms_delete(number)
+    dputs(3) { "Asking to delete #{number} from #{@serial_sms.inspect}" }
+    if @serial_sms.has_key? number.to_s
+      dputs(3) { "Deleting #{number}" }
+      modem_send("AT+CMGD=#{number}", 'OK')
+      @serial_sms.delete number.to_s
+    end
+  end
+
+  def get_operator
+    modem_send('AT+COPS=3,0', 'OK')
+    modem_send('AT+COPS?', 'OK')
+    (1..6).each {
+      if @serial_codes.has_key? 'COPS'
+        return '' if @serial_codes['COPS'] == '0'
+        @serial_eats_sms and modem_send('AT+CNMI=0,0,0,0,0', 'OK')
+        op = @serial_codes['COPS'].scan(/".*?"|[^",]\s*|,,/)[2].gsub(/"/, '')
+        dputs(2) { "Found operator-string #{op}" }
+        return op
+      end
+      sleep 0.5
+    }
+    return ''
+  end
+
+  def set_connection_type(net, modem = :e303)
+    # According to https://wiki.archlinux.org/index.php/3G_and_GPRS_modems_with_pppd
+    cmds = {e303: {c3go: '14,2,3FFFFFFF,0,2', c3g: '2,2,3FFFFFFF,0,2',
+                   c2go: '13,1,3FFFFFFF,0,2', c2g: '2,1,3FFFFFFF,0,2'}}
+    modem_send "AT^SYSCFG=#{cmds[modem]["c#{net}".to_sym]}", 'OK'
+  end
+
+  def traffic_statistics
+
+  end
+
+  def init_modem
+    %w( ATZ
+    AT+CNMI=0,0,0,0,0
+    AT+CPMS="SM","SM","SM"
+    AT+CFUN=1
+    AT+CMGF=1 ).each { |at| modem_send(at, 'OK') }
+    @serial_eats_sms and modem_send('AT+CNMI=0,0,0,0,0', 'OK')
+    set_connection_type '3g'
+  end
+
+  def setup_tty
+    check_presence
+
+    @serial_mutex_rcv.synchronize {
+      if !@serial_sp && @serial_tty
+        if File.exists? @serial_tty
+          dputs(2){ 'setting up SerialPort'}
+          @serial_sp = SerialPort.new(@serial_tty, 115200)
+          @serial_sp.read_timeout = 500
+        end
+      elsif @serial_sp &&
+          (!@serial_tty||(@serial_tty && !File.exists?(@serial_tty)))
+        dputs(2){'disconnecting modem'}
+        kill
+      end
+    }
+    if @serial_sp
+      dputs(2){'initialising modem'}
+      init_modem
+      start_serial_thread
+      if !@serial_sp
+        dputs(2){'Lost serial-connection while initialising - trying again'}
+        kill
+        reload_option
+        setup_tty
+        return
+      end
+      dputs(2){'finished connecting'}
+    end
+  end
+
+  def check_presence
+    @serial_mutex_rcv.synchronize {
+      @serial_tty.to_s.length > 0 and File.exists?(@serial_tty) and return
+      case lsusb = System.run_str('lsusb')
+        when /12d1:1506/, /12d1:14ac/, /12d1:1c05/
+          log_msg :SerialModem, 'Found 3G-modem with ttyUSB0-ttyUSB2'
+          @serial_tty_error = '/dev/ttyUSB3'
+          @serial_tty = '/dev/ttyUSB2'
+          @ussd_add = (lsusb =~ /12d1:14ac/) ? ',15' : ''
+          @serial_eats_sms = true
+        when /airtel-modem/
+          log_msg :SerialModem, 'Found 3G-modem with ttyUSB0-ttyUSB4'
+          @serial_tty_error = '/dev/ttyUSB5'
+          @serial_tty = '/dev/ttyUSB4'
+          @ussd_add = ''
+        else
+          #puts caller.join("\n")
+          @serial_tty = @serial_tty_error = nil
+      end
+      dputs(2){"serial_tty is #{@serial_tty.inspect} and exists " +
+                              "#{File.exists?(@serial_tty.to_s)}"}
+      if @serial_tty_error && File.exists?(@serial_tty_error)
+        log_msg :SerialModem, 'resetting modem'
+        reload_option
+      end
+    }
+  end
+
+  def start_serial_thread
+    @serial_thread = Thread.new {
+      #dputs_func
+      dputs(2){'Thread started'}
+      loop {
+        begin
+          dputs(5) { 'Reading out modem' }
+          if read_reply.length == 0
+            #@serial_sms.each { |id, sms|
+            #  ddputs(3) { "Deleting sms #{sms.inspect} afterwards" }
+            #  sms_delete(id)
+            #}
+          end
+
+          dputs(4) { (Time.now - @serial_ussd_last).to_s }
+          if (Time.now - @serial_ussd_last > @serial_ussd_timeout) &&
+              (@serial_ussd.length > 0)
+            log_msg :SerialModem, "Re-sending #{@serial_ussd.first}"
+            ussd_send_now
+          end
+
+          sms_scan
+
+          sleep 0.5
+        rescue IOError
+          log_msg :SerialModem, 'IOError - killing modem'
+          kill
+          return
+        rescue Exception => e
+          dputs(0) { "#{e.inspect}" }
+          dputs(0) { "#{e.to_s}" }
+          e.backtrace.each { |l| dputs(0) { l } }
+        end
+        dputs(5) { 'Finished' }
+      }
+      dputs(1) { 'Finished thread' }
+    }
+  end
+
+  def reload_option
+    @serial_sp and @serial_sp.close
+    @serial_sp = nil
+    dputs(1) { 'Trying to reload modem-driver - killing and reloading' }
+    %w( chat ppp).each { |pro|
+      System.run_str("killall -9 #{pro}")
+    }
+    %w(rmmod modprobe).each { |cmd|
+      System.run_str("#{cmd} option")
+    }
+  end
+
+  def kill
+    #dputs_func
+    if @serial_thread
+      if @serial_thread.alive?
+        dputs(3) { 'Killing thread' }
+        @serial_thread.kill
+        dputs(3) { 'Joining thread' }
+        @serial_thread.join
+        dputs(3) { 'Thread joined' }
+      end
+    end
+    @serial_sp and @serial_sp.close
+    dputs(1) { 'SerialModem killed' }
+    @serial_sp = nil
+  end
+
+  def attached?
+    @serial_sp != nil
+  end
+
+end

data/serial_modem.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'serial_modem'
+  spec.version       = '0.3.0'
+  spec.authors       = ['Linus Gasser']
+  spec.email         = ['ineiti@linusetviviane.ch']
+  spec.summary       = %q{Interface to serial-usb-modems}
+  spec.description   = %q{This can interface a lot of different usb-modems and serial modems}
+  spec.homepage      = 'https://github.com/ineiti/SerialModem'
+  spec.license       = 'GPLv3'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_runtime_dependency 'serialport', '1.3.1'
+end

data/test/run_test

@@ -0,0 +1,10 @@
+#!/bin/bash
+RP=""
+for a in HilinkModem SerialModem HelperClasses; do
+  RP="$RP -I../../$a/lib"
+done
+for a in activesupport-3.1.1 i18n-0.6.0; do
+  RP="$RP -I../../QooxView/libs/$a/lib"
+done
+echo $RP
+ruby $RP $1

data/test/test_hw.rb

@@ -0,0 +1,59 @@
+#!/bin/env ruby
+#$LOAD_PATH.push '../lib'
+DEBUG_LVL=5
+
+require 'serial_modem'
+include SerialModem
+
+def main
+  test_send_ussd
+end
+
+def test_remove
+  setup_modem
+  check_presence
+  sleep 3
+  kill
+  sleep 5
+  reload_option
+end
+
+def test_send_ussd
+  setup_modem
+  #check_presence
+  ussd_send('*100#')
+  sleep 5
+  #dp 'done'
+end
+
+def test_old
+  setup_modem nil
+  check_presence
+#set_connection_type '2go'
+#sleep 10
+  ussd_send('*128#')
+  sleep 5
+#set_connection_type '3g'
+#sleep 10
+#ussd_send('*128#')
+#sleep 10
+#ussd_send('*128#')
+#sleep 10
+#sleep 1
+#ussd_send('*128#')
+#sms_send('93999699', 'SMS from Dreamplug')
+#sms_send('100', 'internet')
+#sms_scan
+#sleep 10
+#ussd_send('*100#')
+#sms_scan
+#@huawei_sms.each{|k,v| puts "#{k}: #{v.inspect}"}
+#sms_scan
+#sms_delete( 0 )
+#sms_scan
+#sleep 10
+#puts SerialModem::send_modem('atz')
+#sleep 10
+end
+
+main

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: serial_modem
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Linus Gasser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: serialport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+description: This can interface a lot of different usb-modems and serial modems
+email:
+- ineiti@linusetviviane.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- commit
+- lib/serial_modem.rb
+- serial_modem.gemspec
+- test/run_test
+- test/test_hw.rb
+homepage: https://github.com/ineiti/SerialModem
+licenses:
+- GPLv3
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Interface to serial-usb-modems
+test_files:
+- test/run_test
+- test/test_hw.rb