File Coverage

blib/lib/RPi/WiringPi/Util.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


line stmt bran cond sub pod time code
1             package RPi::WiringPi::Util;
2              
3 1     1   581 use strict;
  1         3  
  1         36  
4 1     1   9 use warnings;
  1         3  
  1         91  
5              
6 1     1   11 use parent 'WiringPi::API';
  1         3  
  1         9  
7             use JSON;
8             use RPi::WiringPi::Constant qw(:all);
9              
10             our $VERSION = '2.3620';
11              
12             sub gpio_layout {
13             return $_[0]->gpio_layout;
14             }
15             sub pin_to_gpio {
16             my ($self, $pin, $scheme) = @_;
17              
18             $scheme = defined $scheme
19             ? $scheme
20             : $self->pin_scheme;
21              
22             if ($scheme == RPI_MODE_WPI){
23             return $self->wpi_to_gpio($pin);
24             }
25             elsif ($scheme == RPI_MODE_PHYS){
26             return $self->phys_to_gpio($pin);
27             }
28             elsif ($scheme == RPI_MODE_GPIO){
29             return $pin;
30             }
31             if ($scheme == RPI_MODE_UNINIT){
32             die "setup not run; pin mapping scheme not initialized\n";
33             }
34             }
35             sub pin_map {
36             my ($self, $scheme) = @_;
37              
38             $scheme = $self->pin_scheme if ! defined $scheme;
39              
40             return {} if $scheme eq RPI_MODE_UNINIT;
41              
42             if (defined $self->{pin_map_cache}{$scheme}){
43             return $self->{pin_map_cache}{$scheme};
44             }
45              
46             my %map;
47              
48             for (0..63){
49             my $pin;
50             if ($scheme == RPI_MODE_WPI) {
51             $pin = $self->phys_to_wpi($_);
52             }
53             elsif ($scheme == RPI_MODE_GPIO){
54             $pin = $self->phys_to_gpio($_);
55             }
56             elsif ($scheme == RPI_MODE_PHYS){
57             $pin = $_;
58             }
59             $map{$_} = $pin;
60             }
61             $self->{pin_map_cache}{$scheme} = \%map;
62              
63             return \%map;
64             }
65             sub pin_scheme {
66             my ($self, $scheme) = @_;
67            
68             if (defined $scheme){
69             $ENV{RPI_PIN_MODE} = $scheme;
70             }
71            
72             return defined $ENV{RPI_PIN_MODE}
73             ? $ENV{RPI_PIN_MODE}
74             : RPI_MODE_UNINIT;
75             }
76             sub pwm_range {
77             my ($self, $range) = @_;
78             if (defined $range){
79             $self->{pwm_range} = $range;
80             $self->pwm_set_range($range);
81             }
82             return defined $self->{pwm_range} ? $self->{pwm_range} : 1023;
83             }
84             sub pwm_clock {
85             my ($self, $divisor) = @_;
86             if (defined $divisor){
87             $self->{pwm_clock} = $divisor;
88             $self->pwm_set_clock($divisor);
89             }
90             return defined $self->{pwm_clock} ? $self->{pwm_clock} : 32;
91             }
92             sub pwm_mode {
93             my ($self, $mode) = @_;
94             if (defined $mode && ($mode == 0 || $mode == 1)){
95             $self->{pwm_mode} = $mode;
96             $self->pwm_set_mode($mode);
97             }
98             else {
99             die "pwm_mode() requires either 0 or 1 if a param is sent in\n";
100             }
101             return defined $self->{pwm_mode} ? $self->{pwm_mode} : 1;
102             }
103             sub export_pin {
104             my ($self, $pin) = @_;
105             system "sudo", "gpio", "export", $self->pin_to_gpio($pin), "in";
106             }
107             sub unexport_pin {
108             my ($self, $pin) = @_;
109             system "sudo", "gpio", "unexport", $self->pin_to_gpio($pin);
110             }
111             sub registered_pins {
112             return $_[0]->_pin_registration;
113             }
114             sub register_pin {
115             my ($self, $pin) = @_;
116             $self->_pin_registration($pin, $pin->mode_alt, $pin->read, $pin->mode);
117             }
118             sub unregister_pin {
119             my ($self, $pin) = @_;
120             $self->_pin_registration($pin);
121             }
122             sub cleanup{
123             if ($ENV{PWM_IN_USE}){
124             WiringPi::API::pwm_set_mode(PWM_MODE_BAL);
125             WiringPi::API::pwm_set_clock(32);
126             WiringPi::API::pwm_set_range(1023);
127             }
128              
129             return if ! $ENV{RPI_PINS};
130              
131             my $pins = decode_json $ENV{RPI_PINS};
132              
133             for my $pin (keys %{ $pins }){
134             WiringPi::API::pin_mode_alt($pin, $pins->{$pin}{alt});
135             WiringPi::API::write_pin($pin, $pins->{$pin}{state});
136             WiringPi::API::pin_mode($pin, $pins->{$pin}{mode});
137             }
138             delete $ENV{RPI_PINS};
139             }
140             sub _pin_registration {
141             # manages the registration duties for pins
142              
143             my ($self, $pin, $alt, $state, $mode) = @_;
144              
145             my $json = $ENV{RPI_PINS};
146             my $perl = defined $json ? decode_json $json : {};
147              
148             if (! defined $pin){
149             my @registered_pins = keys %{ $perl };
150             return \@registered_pins;
151             }
152              
153             if (! defined $alt){
154             if (defined $perl->{$self->pin_to_gpio($pin->num)}){
155             $pin->mode_alt($perl->{$pin->num}{alt});
156             $pin->write($perl->{$pin->num}{state});
157             $pin->mode($perl->{$pin->num}{mode});
158             delete $perl->{$self->pin_to_gpio($pin->num)};
159             $ENV{RPI_PINS} = encode_json $perl;
160             return;
161             }
162             }
163              
164             die "_pin_data() requires both \$alt and \$state params\n"
165             if ! defined $state;
166              
167             if (exists $perl->{$self->pin_to_gpio($pin->num)}){
168             my $gpio_pin_num = $self->pin_to_gpio($pin->num);
169             die "pin $gpio_pin_num is already in use, can't continue...\n";
170             }
171              
172             $perl->{$self->pin_to_gpio($pin->num)}{alt} = $alt;
173             $perl->{$self->pin_to_gpio($pin->num)}{state} = $state;
174             $perl->{$self->pin_to_gpio($pin->num)}{mode} = $mode;
175              
176             my @registered_pins = keys %{ $perl };
177              
178             $json = encode_json $perl;
179            
180             $ENV{RPI_PINS} = $json;
181              
182             return \@registered_pins;
183             }
184             sub _vim{1;};
185             1;
186              
187             __END__