new_remote 0.1.0

data/ext/new_remote/new_remote.cpp

@@ -0,0 +1,173 @@
+#include <ruby.h>
+#include <iostream>
+#include <csignal>
+
+#include "NewRemoteReceiver.h"
+#include "NewRemoteTransmitter.h"
+
+typedef void (*sighandler_t)(int);
+
+static sighandler_t old_sig_int_handler, old_sig_term_handler;
+static bool signal_received = false;
+
+static void wrap_receiver_callback(NewRemoteCode);
+static VALUE wrap_receiver_receive(VALUE, VALUE, VALUE);
+
+static void wrap_transmitter_free(NewRemoteTransmitter *);
+static VALUE wrap_transmitter_allocate(VALUE);
+static VALUE wrap_transmitter_initialize(int, VALUE *, VALUE);
+static VALUE wrap_transmitter_send_group(VALUE, VALUE);
+static VALUE wrap_transmitter_send_unit(VALUE, VALUE, VALUE);
+static VALUE wrap_transmitter_send_group_dim(VALUE, VALUE);
+static VALUE wrap_transmitter_send_unit_dim(VALUE, VALUE, VALUE);
+
+static void new_remote_signal_handler(int s) {
+	/* Restore previous signal handler on a SIGINT/SIGTERM. */
+	signal(SIGINT, old_sig_int_handler);
+	signal(SIGTERM, old_sig_term_handler);
+
+	signal_received = true;
+}
+
+static void wrap_receiver_callback(NewRemoteCode code) {
+	std::cout << "Address: " <<  code.address << ", ";
+
+	if (code.groupBit) {
+		std::cout << "group, ";
+	} else {
+		std::cout << "unit: " << static_cast<int>(code.unit) << ", ";
+	}
+
+	switch (code.switchType) {
+	case NewRemoteCode::off:
+		std::cout << "off, ";
+		break;
+	case NewRemoteCode::on:
+		std::cout << "on, ";
+		break;
+	case NewRemoteCode::dim:
+		std::cout << "dim, ";
+		break;
+	}
+
+	if (code.dimLevelPresent) {
+		std::cout << "dim level: " << static_cast<int>(code.dimLevel) << ", ";
+	}
+
+	std::cout << "period: " << code.period << "us." << std::endl;
+}
+
+static VALUE wrap_receiver_receive(VALUE self, VALUE pin, VALUE minRepeats) {
+	NewRemoteReceiver::init(NUM2INT(pin), NUM2INT(minRepeats), wrap_receiver_callback);
+
+	/* Wait forever until receiving SIGINT/SIGTERM. */
+	while (!signal_received) {
+		sleep(1);
+	}
+
+	return self;
+}
+
+static void wrap_code_free(NewRemoteCode *code) {
+	ruby_xfree(code);
+}
+
+static VALUE wrap_code_allocate(VALUE klass) {
+	return Data_Wrap_Struct(klass, NULL, wrap_code_free, ruby_xmalloc(sizeof(NewRemoteCode)));
+}
+
+static NewRemoteTransmitter *getNewRemoteTransmitter(VALUE self) {
+        NewRemoteTransmitter *transmitter;
+
+        Data_Get_Struct(self, NewRemoteTransmitter, transmitter);
+
+	return transmitter;
+}
+
+static void wrap_transmitter_free(NewRemoteTransmitter *transmitter) {
+	transmitter->~NewRemoteTransmitter();
+	ruby_xfree(transmitter);
+}
+
+static VALUE wrap_transmitter_allocate(VALUE klass) {
+	return Data_Wrap_Struct(klass, NULL, wrap_transmitter_free, ruby_xmalloc(sizeof(NewRemoteTransmitter)));
+}
+
+static VALUE wrap_transmitter_initialize(int argc, VALUE *argv, VALUE self) {
+	NewRemoteTransmitter *transmitter = getNewRemoteTransmitter(self);
+	VALUE address, pin, periodusec, repeats;
+
+	rb_scan_args(argc, argv, "22", &address, &pin, &periodusec, &repeats);
+
+	if (NIL_P(periodusec)) {
+		periodusec = INT2NUM(260);
+	}
+
+	if (NIL_P(repeats)) {
+		repeats = INT2NUM(4);
+	}
+
+	new(transmitter) NewRemoteTransmitter(NUM2INT(address), NUM2INT(pin), NUM2INT(periodusec), NUM2INT(repeats));
+
+	return Qnil;
+}
+
+static VALUE wrap_transmitter_send_group(VALUE self, VALUE state) {
+	NewRemoteTransmitter *transmitter = getNewRemoteTransmitter(self);
+
+	transmitter->sendGroup(RTEST(state));
+
+	return self;
+}
+
+static VALUE wrap_transmitter_send_unit(VALUE self, VALUE device, VALUE state) {
+	NewRemoteTransmitter *transmitter = getNewRemoteTransmitter(self);
+
+	transmitter->sendUnit(NUM2INT(device), RTEST(state));
+
+	return self;
+}
+
+static VALUE wrap_transmitter_send_group_dim(VALUE self, VALUE dimLevel) {
+	NewRemoteTransmitter *transmitter = getNewRemoteTransmitter(self);
+
+	transmitter->sendGroupDim(NUM2INT(dimLevel));
+
+	return self;
+}
+
+static VALUE wrap_transmitter_send_unit_dim(VALUE self, VALUE device, VALUE dimLevel) {
+	NewRemoteTransmitter *transmitter = getNewRemoteTransmitter(self);
+
+	transmitter->sendDim(NUM2INT(device), NUM2INT(dimLevel));
+
+	return self;
+}
+
+extern "C" void Init_new_remote() {
+	VALUE NewRemoteModule = rb_define_module("NewRemote");
+
+        /* Receiver class definitions. */
+	VALUE ReceiverClass = rb_define_class_under(NewRemoteModule, "Receiver", rb_cObject);
+
+	rb_define_singleton_method(ReceiverClass, "receive", RUBY_METHOD_FUNC(wrap_receiver_receive), 2);
+
+	/* Transmitter class definitions. */
+	VALUE TransmitterClass = rb_define_class_under(NewRemoteModule, "Transmitter", rb_cObject);
+
+	rb_define_alloc_func(TransmitterClass, wrap_transmitter_allocate);
+	rb_define_method(TransmitterClass, "initialize", RUBY_METHOD_FUNC(wrap_transmitter_initialize), -1);
+	rb_define_method(TransmitterClass, "send_group", RUBY_METHOD_FUNC(wrap_transmitter_send_group), 1);
+	rb_define_method(TransmitterClass, "send_unit", RUBY_METHOD_FUNC(wrap_transmitter_send_unit), 2);
+	rb_define_method(TransmitterClass, "send_group_dim", RUBY_METHOD_FUNC(wrap_transmitter_send_group_dim), 1);
+	rb_define_method(TransmitterClass, "send_unit_dim", RUBY_METHOD_FUNC(wrap_transmitter_send_unit_dim), 2);
+
+	if (wiringPiSetup() == -1) {
+		std::cerr << "WiringPi setup failed." << std::endl;
+		exit(1);
+	}
+
+	/* Catch SIGINT/SIGTERM with our own signal handler. */
+	old_sig_int_handler = signal(SIGINT, new_remote_signal_handler);
+	old_sig_term_handler = signal(SIGTERM, new_remote_signal_handler);
+}

data/lib/new_remote.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "new_remote/new_remote"
+require "new_remote/version"
+
+module NewRemote
+  class UnitCommand
+    def initialize(transmitter, device)
+      @transmitter = transmitter
+      @device = device
+    end
+
+    def on
+      @transmitter.send_unit(@device, true)
+    end
+
+    def off
+      @transmitter.send_unit(@device, false)
+    end
+
+    def dim(level)
+      @transmitter.send_unit_dim(@device, level)
+    end
+  end
+
+  class GroupCommand
+    def initialize(transmitter)
+      @transmitter = transmitter
+    end
+
+    def on
+      @transmitter.send_group(true)
+    end
+
+    def off
+      @transmitter.send_group(false)
+    end
+
+    def dim(level)
+      @transmitter.send_group_dim(level)
+    end
+  end
+
+  class Transmitter
+    def unit(device)
+      UnitCommand.new(self, device)
+    end
+
+    def group
+      GroupCommand.new(self)
+    end
+  end
+end

data/lib/new_remote/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NewRemote
+  VERSION = "0.1.0"
+end

data/new_remote.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "new_remote/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "new_remote"
+  spec.version       = NewRemote::VERSION
+  spec.authors       = ["Peter Postma"]
+  spec.email         = ["peter.postma@gmail.com"]
+
+  spec.summary       = "NewRemoteSwitch for Arduino ported to Raspberry Pi"
+  spec.homepage      = "https://github.com/ppostma/NewRemoteSwitch"
+  spec.license       = "GPL-3.0"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.extensions    = %w[ext/new_remote/extconf.rb]
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler", "~> 1.0"
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: new_remote
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter Postma
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !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: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: 
+email:
+- peter.postma@gmail.com
+executables: []
+extensions:
+- ext/new_remote/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/new_remote/NewRemoteReceiver.cpp
+- ext/new_remote/NewRemoteReceiver.h
+- ext/new_remote/NewRemoteTransmitter.cpp
+- ext/new_remote/NewRemoteTransmitter.h
+- ext/new_remote/extconf.rb
+- ext/new_remote/license.txt
+- ext/new_remote/new_remote.cpp
+- lib/new_remote.rb
+- lib/new_remote/version.rb
+- new_remote.gemspec
+homepage: https://github.com/ppostma/NewRemoteSwitch
+licenses:
+- GPL-3.0
+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.7.8
+signing_key: 
+specification_version: 4
+summary: NewRemoteSwitch for Arduino ported to Raspberry Pi
+test_files: []