File Coverage

blib/lib/Device/MindWave.pm

Criterion	Covered	Total	%
statement	132	147	89.8
branch	43	48	89.5
condition	6	6	100.0
subroutine	19	19	100.0
pod	8	8	100.0
total	208	228	91.2

package Device::MindWave;

use strict;
use warnings;

use Device::SerialPort;
use Device::MindWave::Utils qw(checksum
                               packet_isa);
use Device::MindWave::Packet::Parser;

our $VERSION = '0.02';
our $_NO_SLEEP = 0;

sub new
{
    my $class = shift;
    my %args = @_;

    my $port;
    if (exists $args{'fh'}) {
        $port = $args{'fh'};
    } elsif (exists $args{'port'}) {
        $port = Device::SerialPort->new($args{'port'});
        if (not $port) {
            die "Cannot open ".($args{'port'}).": $!";
        }
        $port->baudrate(115200);
        $port->user_msg(0);
        $port->parity("even");
        $port->databits(8);
        $port->stopbits(1);
        $port->handshake("none");
        $port->read_const_time(1000);
        $port->read_char_time(5);
        $port->write_settings();
    } else {
        die "Either 'fh' or 'port' must be provided.";
    }

    my $self = { port   => $port,
                 is_fh  => (exists $args{'fh'}),
                 parser => Device::MindWave::Packet::Parser->new() };
    bless $self, $class;
    return $self;
}

sub _sleep
{
    if ($_NO_SLEEP) {
        return 1;
    }
    sleep($_[0]);
    return 1;
}

sub _read
{
    my ($self, $len) = @_;

    my $buf;
    my $bytes;
    if ($self->{'is_fh'}) {
        $bytes = $self->{'port'}->read($buf, $len);
    } else {
        $buf = $self->{'port'}->read($len);
        $bytes = length $buf;
    }

    if ($len != (length $buf)) {
        die "Received too few characters on read ($bytes instead of $len).";
    }

    return $buf;
}

sub _write
{
    my ($self, $data) = @_;

    if ($self->{'is_fh'}) {
        $self->{'port'}->write($data, (length $data), 0);
    } else {
        $self->{'port'}->write($data);
    }

    return 1;
}

sub _write_bytes
{
    my ($self, $bytes) = @_;

    my $data = join '', map { chr($_) } @{$bytes};
    return $self->_write($data);
}

sub _to_headset_id_bytes
{
    my ($upper, $lower) = @_;

    if ($upper > 255) {
        $lower = $upper & 0xFF;
        $upper = ($upper >> 8) & 0xFF;
    }

    return ($upper, $lower);
}

sub _wait_for_standby
{
    my ($self) = @_;

    my $tries = 15;
    while ($tries--) {
        my $packet = $self->read_packet();
        if (packet_isa($packet, 'Dongle::StandbyMode')) {
            return 1;
        }
        _sleep(1);
    }

    die "Timed out waiting for standby packet (15s).";
}

sub connect_nb
{
    my ($self, $upper, $lower) = @_;

    ($upper, $lower) = _to_headset_id_bytes($upper, $lower);
    $self->_write_bytes([ 0xC0, $upper, $lower ]);

    return 1;
}

sub connect
{
    my ($self, @args) = @_;

    $self->_wait_for_standby();
    $self->connect_nb(@args);

    my $tries = 15;
    while ($tries--) {
        my $packet = $self->read_packet();
        if (packet_isa($packet, 'Dongle::HeadsetFound')) {
            return 1;
        } elsif (packet_isa($packet, 'Dongle::HeadsetNotFound')) {
            die "Headset not found.";
        } elsif (packet_isa($packet, 'Dongle::RequestDenied')) {
            die "Request denied by dongle.";
        }
        _sleep(1);
    }

    die "Unable to connect to headset.";
}

sub auto_connect_nb
{
    my ($self) = @_;

    $self->_write_bytes([ 0xC2 ]);

    return 1;
}

sub auto_connect
{
    my ($self) = @_;

    $self->_wait_for_standby();
    $self->auto_connect_nb();

    my $tries = 15;
    while ($tries--) {
        my $packet = $self->read_packet();
        if (packet_isa($packet, 'Dongle::HeadsetFound')) {
            return 1;
        } elsif (packet_isa($packet, 'Dongle::HeadsetNotFound')) {
            die "No headset was found.";
        } elsif (packet_isa($packet, 'Dongle::RequestDenied')) {
            die "Request denied by dongle.";
        }
        _sleep(1);
    }

    die "Unable to connect to any headset.";
}

sub disconnect_nb
{
    my ($self) = @_;

    $self->_write_bytes([ 0xC1 ]);

    return 1;
}

sub disconnect
{
    my ($self) = @_;

    $self->disconnect_nb();

    my $tries = 15;
    my $got_error = 0;
    while ($tries--) {
        # Allow one error during packet read, since there will
        # occasionally be a packet length mismatch problem.
        my $packet = eval { $self->read_packet() };
        if (my $error = $@) {
            if ($got_error == 1) {
                die $error;
            } else {
                $got_error = 1;
            }
        }
        # Flush the remaining ThinkGear packets.
        if (packet_isa($packet, 'ThinkGear')) {
            $tries++;
            next;
        }
        if (packet_isa($packet, 'Dongle::HeadsetDisconnected')
                or packet_isa($packet, 'Dongle::StandbyMode')) {
            # Occasionally, no HeadsetDisconnected packet will be
            # returned, hence the check for standby mode.
            return 1;
        } elsif (packet_isa($packet, 'Dongle::RequestDenied')) {
            die "Request denied by dongle.";
        }
        _sleep(1);
    }

    die "Unable to disconnect from headset.";
}

sub read_packet
{
    my ($self) = @_;

    my $tries = 1001;
    my $prev_byte = 0;
    while (--$tries) {
        my $length = 0;
        my $byte = $self->_read(1);
        if (((ord $prev_byte) == 0xAA) and ((ord $byte) == 0xAA)) {
            last;
        } else {
            $prev_byte = $byte;
        }
    }

    if ($tries == 0) {
        die "Unable to find synchronisation bytes (read 1000 bytes).";
    }

    my $len = ord $self->_read(1);
    if ($len > 169) {
        die "Length byte has invalid value ($len): expected 0-169.";
    }

    my $data = $self->_read($len);
    my @bytes = map { ord $_ } split //, $data;

    my $checksum = ord $self->_read(1);
    my $checksum_actual = checksum(\@bytes);

    if ($checksum != $checksum_actual) {
        goto &read_packet;
    }

    return $self->{'parser'}->parse(\@bytes);
}

1;

__END__