File Coverage

blib/lib/RPi/WiringPi/Core.pm

Criterion	Covered	Total	%
statement	9	9	100.0
branch			n/a
condition			n/a
subroutine	3	3	100.0
pod			n/a
total	12	12	100.0

package RPi::WiringPi::Core;

use strict;
use warnings;

use parent 'WiringPi::API';
use JSON;
use RPi::Const qw(:all);

our $VERSION = '2.3621';

sub gpio_layout {
    return $_[0]->gpio_layout;
}
sub pin_to_gpio {
    my ($self, $pin, $scheme) = @_;

    $scheme = defined $scheme
        ? $scheme
        : $self->pin_scheme;

    if ($scheme == RPI_MODE_WPI){
        return $self->wpi_to_gpio($pin);
    }
    elsif ($scheme == RPI_MODE_PHYS){
        return $self->phys_to_gpio($pin);
    }
    elsif ($scheme == RPI_MODE_GPIO){
        return $pin;
    }
    if ($scheme == RPI_MODE_UNINIT){
        die "setup not run; pin mapping scheme not initialized\n";
    }
}
sub pin_map {
    my ($self, $scheme) = @_;

    $scheme = $self->pin_scheme if ! defined $scheme;

    return {} if $scheme eq RPI_MODE_UNINIT;

    if (defined $self->{pin_map_cache}{$scheme}){
        return $self->{pin_map_cache}{$scheme};
    }

    my %map;

    for (0..63){
        my $pin;
        if ($scheme == RPI_MODE_WPI) {
            $pin = $self->phys_to_wpi($_);
        }
        elsif ($scheme == RPI_MODE_GPIO){
            $pin = $self->phys_to_gpio($_);
        }
        elsif ($scheme == RPI_MODE_PHYS){
            $pin = $_;
        }
        $map{$_} = $pin;
    }
    $self->{pin_map_cache}{$scheme} = \%map;

    return \%map;
}
sub pin_scheme {
    my ($self, $scheme) = @_;

    if (defined $scheme){
        $ENV{RPI_PIN_MODE} = $scheme;
    }

    return defined $ENV{RPI_PIN_MODE}
        ? $ENV{RPI_PIN_MODE}
        : RPI_MODE_UNINIT;
}
sub pwm_range {
    my ($self, $range) = @_;
    if (defined $range){
        $self->{pwm_range} = $range;
        $self->pwm_set_range($range);
    }
    return defined $self->{pwm_range} ? $self->{pwm_range} : 1023;
}
sub pwm_clock {
    my ($self, $divisor) = @_;
    if (defined $divisor){
        $self->{pwm_clock} = $divisor;
        $self->pwm_set_clock($divisor);
    }
    return defined $self->{pwm_clock} ? $self->{pwm_clock} : 32;
}
sub pwm_mode {
    my ($self, $mode) = @_;
    if (defined $mode && ($mode == 0 || $mode == 1)){
        $self->{pwm_mode} = $mode;
        $self->pwm_set_mode($mode);
    }
    else {
        die "pwm_mode() requires either 0 or 1 if a param is sent in\n";
    }
    return defined $self->{pwm_mode} ? $self->{pwm_mode} : 1;
}
sub export_pin {
    my ($self, $pin) = @_;
    system "sudo", "gpio", "export", $self->pin_to_gpio($pin), "in";
}
sub unexport_pin {
    my ($self, $pin) = @_;
    system "sudo", "gpio", "unexport", $self->pin_to_gpio($pin);
}
sub registered_pins {
    return $_[0]->_pin_registration;
}
sub register_pin {
    my ($self, $pin) = @_;
    $self->_pin_registration($pin, $pin->mode_alt, $pin->read, $pin->mode);
}
sub unregister_pin {
    my ($self, $pin) = @_;
    $self->_pin_registration($pin);
}
sub cleanup{
    if ($ENV{PWM_IN_USE}){
        #FIXME: aack! magic numbers... yuck!
        WiringPi::API::pwm_set_mode(PWM_MODE_BAL);
        WiringPi::API::pwm_set_clock(32);
        WiringPi::API::pwm_set_range(1023);
    }

    return if ! $ENV{RPI_PINS};

    my $pins = decode_json $ENV{RPI_PINS};

    for my $pin (keys %{ $pins }){
        WiringPi::API::pin_mode_alt($pin, $pins->{$pin}{alt});
        WiringPi::API::write_pin($pin, $pins->{$pin}{state});
        WiringPi::API::pin_mode($pin, $pins->{$pin}{mode});
    }
    delete $ENV{RPI_PINS};
}
sub _pin_registration {
    # manages the registration duties for pins

    my ($self, $pin, $alt, $state, $mode) = @_;

    my $json = $ENV{RPI_PINS};
    my $perl = defined $json ? decode_json $json : {};

    if (! defined $pin){
        my @registered_pins = keys %{ $perl };
        return \@registered_pins;
    }

    if (! defined $alt){
        if (defined $perl->{$self->pin_to_gpio($pin->num)}){
            $pin->mode_alt($perl->{$pin->num}{alt});
            $pin->write($perl->{$pin->num}{state});
            $pin->mode($perl->{$pin->num}{mode});
            delete $perl->{$self->pin_to_gpio($pin->num)};
            $ENV{RPI_PINS} = encode_json $perl;
            return;
        }
    }

    die "_pin_registration() requires both \$alt and \$state params\n"
      if ! defined $state;

    if (exists $perl->{$self->pin_to_gpio($pin->num)}){
        my $gpio_pin_num = $self->pin_to_gpio($pin->num);
        die "pin $gpio_pin_num is already in use, can't continue...\n";
    }

    $perl->{$self->pin_to_gpio($pin->num)}{alt} = $alt;
    $perl->{$self->pin_to_gpio($pin->num)}{state} = $state;
    $perl->{$self->pin_to_gpio($pin->num)}{mode} = $mode;

    my @registered_pins = keys %{ $perl };

    $json = encode_json $perl;

    $ENV{RPI_PINS} = $json;

    return \@registered_pins;
}
sub _vim{1;};
1;

__END__