File Coverage

blib/lib/Device/RFXCOM/TX.pm

Criterion	Covered	Total	%
statement	75	80	93.7
branch	19	26	73.0
condition	1	2	50.0
subroutine	19	20	95.0
pod	8	8	100.0
total	122	136	89.7

use strict;
use warnings;
package Device::RFXCOM::TX;
$Device::RFXCOM::TX::VERSION = '1.142010';
# ABSTRACT: Module to support an RFXCOM RF transmitter


use 5.006;
use constant {
  DEBUG => $ENV{DEVICE_RFXCOM_TX_DEBUG},
  TESTING => $ENV{DEVICE_RFXCOM_TX_TESTING},
};
use base 'Device::RFXCOM::Base';
use Carp qw/croak carp/;
use IO::Handle;
use IO::Select;
use Module::Pluggable
  search_path => 'Device::RFXCOM::Encoder',
  instantiate => 'new';


sub new {
  my $pkg = shift;
  my $self = $pkg->SUPER::_new(device => '/dev/rfxcom-tx',
                               ack_timeout => 6,
                               receiver_connected => 0,
                               flamingo => 0,
                               harrison => 0,
                               koko => 0,
                               x10 => 1,
                               @_);
  foreach my $plugin ($self->plugins()) {
    my $p = lc ref $plugin;
    $p =~ s/.*:://;
    $self->{plugin_map}->{$p} = $plugin;
    print STDERR "Initialized plugin for $p messages\n" if DEBUG;
  }
  $self;
}


sub receiver_connected { shift->{receiver_connected} }


sub flamingo { shift->{flamingo} }


sub harrison { shift->{harrison} }


sub koko { shift->{koko} }


sub x10 { shift->{x10} }

sub _init {
  my $self = shift;
  $self->_write(hex => 'F030F030', desc => 'version check');
  $self->_write(hex => 'F03CF03C', desc => 'enabling harrison')
    if ($self->harrison);
  $self->_write(hex => 'F03DF03D', desc => 'enabling klikon-klikoff')
    if ($self->koko);
  $self->_write(hex => 'F03EF03E', desc => 'enabling flamingo')
    if ($self->flamingo);
  $self->_write(hex => 'F03FF03F', desc => 'disabling x10') unless ($self->x10);
  $self->_init_mode($self->{init_callback});
  $self->{init} = 1;
}

sub _init_mode {
  my ($self, $cb) = @_;
  my @args =
    $self->receiver_connected ?
      (hex => 'F033F033',
       desc => 'variable length mode w/receiver connected') :
         (hex => 'F037F037',
          desc=> 'variable length mode w/o receiver connected');
  push @args, callback => $cb if ($cb);
  $self->_write(@args);
}

sub _reset_device {
  my $self = shift;
  carp "No ack from transmitter!\n";
  $self->init_device();
  1;
}


sub transmit {
  my ($self, %p) = @_;
  my $type = $p{type} || 'x10';
  my @args = @{$p{args}||[]};
  my $plugin = $self->{plugin_map}->{$type} or
    croak $self, '->transmit: ', $type, ' encoding not supported';
  my $encode = $plugin->encode($self, \%p);
  if (ref $encode eq 'ARRAY') {
    foreach my $e (@$encode) {
      $self->_write(%$e, @args);
    }
    return scalar @$encode;
  } else {
    $self->_write(%$encode, @args);
    return 1;
  }
}


sub wait_for_ack {
  my ($self, $timeout) = @_;
  $timeout = $self->{ack_timeout} unless (defined $timeout);
  my $fh = $self->filehandle;
  my $sel = IO::Select->new($fh);
  $sel->can_read($timeout) or return;
  my $buf;
  my $bytes = sysread $fh, $buf, 2048;
  unless ($bytes) {
    croak defined $bytes ? 'closed' : 'error: '.$!;
  }
  $self->_write_now();
  print STDERR "Received: ", (unpack 'H*', $buf), "\n" if DEBUG;
  return $buf;
}

1;

__END__