head

code

item

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

RPi::Device::DHT11 - Interface to the DHT11 digital temperature/humidity sensor


=begin code

use RPi::Device::DHT11;

sub MAIN() {
    my $dht = RPi::Device::DHT11.new(pin => 0, supply-interval => 1.5);

    react {
        whenever $dht -> $reading {
            say sprintf "{ DateTime.now.Str }: Humidity is %.2f %%, \t Temperature is %.2f *C", $reading.humidity, $reading.temperature;
        }
    }
}
=end code


The DHT11 is a common and inexpensive temperate and humidity sensor with a single pin digital interface. It has a reasonable degree of accuracy ( 1-2% on relative humidity and 0.2°C or so.)


To hook the DHT11 up you only need a pull-up resistor (the datasheets indicate 5KΩ but 10K seems to work fine.) It will not work reliably (or at all,) without the pull-up.


[![Minimal Circuit](examples/hardware/dht11.png)](examples/hardware/dht11.png)


Please note that because this uses the wiringPi library under the hood the [wiringPi pin numbers](http://wiringpi.com/pins/) are used, so in the above the data line is connected to the sixth pin down from the top on the left (assuming the end with the USB is "down",) which is wiringPi pin 0 (or GPIO 17 in the Broadcom numbering.) You can find the actual numbering for your Raspberry Pi with:


The easiest way to use this module is to use the object as a `Supply` as in the example above (it supplies a `Supply` coercion,) this will emit a `Reading` object at a minimum of `supply-interval` seconds frequency (the default is 1.5 seconds which is about the minimum usable value.)  The `Reading` object has `temperature` (in degrees Celsius,) and `humidity` (in percentage relative humidity,) attribute.


The `read` method returns a `Reading` object if a valid reading is obtained in `read-retries` attempts, or a type object otherwise, this doesn't place a constraint on how frequently it is called but you are likely to get fewer valid readings if call more frequently than 1.5 seconds.


You could potentially use multiple instances of this on different pins (having more than one on the same pin is guaranteed not to work,) but you should bear in mind that the code has to spin in a tight loop while it is getting a reading so you might experience high processor load and/or unreliable readings if you have too many.



class RPi::Device::DHT11 {

    use NativeCall;

    constant LIB = %?RESOURCES<libraries/dht>.Str;

    constant DHTLIB_OK               =  0;
    constant DHTLIB_ERROR_CHECKSUM   =  -1;
    constant DHTLIB_ERROR_TIMEOUT    =  -2;
    constant DHTLIB_INVALID_VALUE    =  -999;
    constant DHTLIB_DHT11_WAKEUP     =  20;
    constant DHTLIB_DHT_WAKEUP       =  1;
    constant DHTLIB_TIMEOUT          =  120;


    #| The wiringPi Pin number
    has Int     $.pin is required;
    #| The minimum interval at which Reading objects will be emitted by Supply, default is 1.5
    has Numeric $.supply-interval   = 1.5;
    #| The number of times a read will be tried to get a valid reading, default is 15
    has Int     $.read-retries      = 15;

    #| The temperature in Celsius after the most recent reading
    has Numeric $.temperature;
    #| The humidity as a percentage after the most recent reading
    has Numeric $.humidity;



    method TWEAK() {
        $!data.init();
    }

    class Data is repr('CStruct') {
        HAS uint8 @.bits[5] is CArray;

        method TWEAK() {
            for ^5 -> $i {
                @!bits[$i] = 0;
            }
        }
        sub read_sensor(Data $data is rw, uint32 $pin, uint32 $wakeup-delay --> int32 ) is native(LIB) { * }

        method read-sensor(uint32 $pin, uint32 $wakeup-delay --> int32) {
            read_sensor(self, $pin, $wakeup-delay);
        }

        sub init_dh11( --> int32 ) is native(LIB) { * }

        method init() {
            init_dh11();
        }
    }


    has Data $.data handles <read-sensor> = Data.new;


    method read-once( --> Int ) {
        given self.read-sensor($!pin, DHTLIB_DHT11_WAKEUP) {
            when DHTLIB_OK {
                $!humidity = $!data.bits[0];
                $!temperature = $!data.bits[2] + $!data.bits[3] * 0.1;
                my $sum = $!data.bits[^4].sum;
                if $!data.bits[4] != $sum {
                    DHTLIB_ERROR_CHECKSUM;
                }
                else {
                    $_;
                }
            }
            default {
                $!humidity = DHTLIB_INVALID_VALUE;
                $!temperature = DHTLIB_INVALID_VALUE;
                $_;
            }
        }

    }

    #| Class representing a single reading
    class Reading {
        #| The temperature in celcius for this reading
        has Numeric $.temperature;
        #| The humidity expressed as percentage for this reading
        has Numeric $.humidity;
    }

    #| Attempt to get a single reading, attempting at most read-retries.
    #| Returns a Reading object if successfull, a type object otherwise
    method read( --> Reading ) {
        my Reading $rv;
        for ^$!read-retries {
            given self.read-once {
                when DHTLIB_OK {
                    $rv = Reading.new(temperature => $.temperature, humidity => $.humidity);
                    last;
                }
            }
        }
        $rv;
    }

    #| Supply coercion, emits Reading objects at a minimum of supply-interval frequency
    method Supply( --> Supply ) {
        supply {
            whenever Supply.interval($!supply-interval) -> $ {
                    if self.read -> $reading {
                        emit $reading;
                    }
            }
        }
    }

}
# vim: ft=raku


DHT11

use v6.c;
use NativeCall;
use RPi::Wiring::Pi;

enum Edge < RISING FALLING BOTH >;
enum PUD < PULL_UP PULL_DOWN PULL_OFF >;

class RPi::ButtonWatcher {
    has %!gpio-to-wiring-pins{Int};
    has %!prev-vals{Int};
    has Edge $!edge;
    has $!button-supplier = Supplier.new;
    has $!debounce;

    submethod BUILD(:@pins, Edge:D :$!edge, PUD:D :$PUD, :$!debounce = 0.1) {
        %!gpio-to-wiring-pins{wpiPinToGpio($_)} = $_ for @pins;

        self!setup: $PUD;

        for %!gpio-to-wiring-pins.keys -> $gpio-pin {
            %!prev-vals{$gpio-pin} = slurp("/sys/class/gpio/gpio$gpio-pin/value").substr(0,1);
        }

        Thread.start({
            while True {
                sleep $!debounce;
                for %!gpio-to-wiring-pins.keys -> $gpio-pin {
                    my $res = slurp("/sys/class/gpio/gpio$gpio-pin/value").substr(0, 1);
                    if %!prev-vals{$gpio-pin} ne $res {
                        %!prev-vals{$gpio-pin} = $res;
                        self!callback: $gpio-pin, $res.ord;
                    }
                }
            }
        });
    }

    method !setup(PUD $PUD) {
        for %!gpio-to-wiring-pins.kv -> $gpio-pin, $wpi-pin {
            # Configure pin as input
            pinMode $wpi-pin, INPUT;

            # Set pin to pull up
            pullUpDnControl $wpi-pin, ($PUD == PULL_UP ?? PUD_UP !! $PUD == PULL_DOWN ?? PUD_DOWN !! PUD_OFF);

            # Setup the sysfs interface
            spurt '/sys/class/gpio/export', "$gpio-pin\n" if ! "/sys/class/gpio/gpio$gpio-pin".IO.d;
            die "Couldn't export pin $gpio-pin"           if ! "/sys/class/gpio/gpio$gpio-pin".IO.d;

            sleep 0.1; #Sleep a bit. Otherwise the following spurts will fail with an access denied exception.

            spurt "/sys/class/gpio/gpio$gpio-pin/direction", "in\n";
        }
    }

    method !callback(int32 $gpio-pin, uint8 $val) {
        my $observed-edge = $val == '1'.ord ?? RISING !! FALLING;
        if $!edge == BOTH || $!edge == $observed-edge {
            $!button-supplier.emit: {
                pin => %!gpio-to-wiring-pins{$gpio-pin},
                edge => $observed-edge,
            };
        }
    }

    method getSupply() {
        return $!button-supplier.Supply;
    }
}



RPi::ButtonWatcher - A button push event supplier


use RPi::Wiring::Pi;
use RPi::ButtonWatcher;


# Takes WiringPi pin numbers.
my $watcher = RPi::ButtonWatcher.new(pins => ( 4, 5, 6 ), edge => BOTH, PUD => PULL_UP);
$watcher.getSupply.tap( -> %v {
    my $e = %v<edge> == Edge.RISING ?? 'up' !! 'down';
    say "Pin: %v<pin>, Edge: $e";
});


This library provides a supplier of GPIO pin state changes.


Read/write access to I</sys/class/gpio/export> and I</sys/class/gpio/gpioXX/>
is required for this library to work. This usually means the user running the
code has to be in the I<gpio> group.


This module uses polling to detect state changes. A polling interval of 0.1
seconds is usually fast enough for normal button pushes.


The Sysfs interface is documented here: L<https://www.kernel.org/doc/Documentation/gpio/sysfs.txt>


Do initialize WiringPi before using this class using C<wiringPiSetup>!


A list of WiringPi pin numbers to watch.


Triggered on both, button presses and releases.


Time in seconds to sleep between polls. Faster means more responsive, but also
more system resource eating.
Defaults to 0.1 (100ms).


Returns a supply that can be tapped. The supply will emit
hashes with two entries:


The WiringPi pin number that was triggered.


Either C<Edge.RISING> or C<Edge.FALLING>.


ButtonWatcher

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

DESCRIPTION

METHODS

new

getSupply

RPi::ButtonWatcher v1.0.0

Authors

License

Dependencies

Test Dependencies

Provides

Documentation