head

code

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::SMBus - SMBus/i²c interface for Raspberry Pi


=begin code

    use RPi::Device::SMBus;

    # Obviously you will need to actually read the data sheet of your device.
    my RPi::Device::SMBus $smbus = RPi::Device::SMBus.new(device => '/dev/i2c-1', address => 0x54);

    $smbus.write-byte(0x10);

    ....


=end code


This is an SMBus/i²c interface that has been written and tested for
the Raspberry Pi, however it uses a fairly generic POSIX interface so if
your platform exposes the i²c interface as a character special device
it may work.


In order to use this you will need to install and configure the i2c-dev
kernel module and tools.  On a default Debian image you should be able
to just do:


sudo apt-get install libi2c-dev i2c-tools


And then edit the C</etc/modules> to add the modules by adding:


Typicaly the i2c device will be C</dev/i2c-1> on a Raspberry Pi rev B. or v2 or C</dev/i2c-0> on older versions.


You can determine the bus address of your device by doing:


sudo i2cdetect -y 1  # replace the 1 with a 0 for older versions


(Obviously the device should be connected, consult the manual for your
device about this.)


Which should give you the hexadecimal address of your device.  Some
devices may not respond, so you may want to either check the data sheet
of your device or read the C<i2cdetect> manual page to get other options.


Not all devices will necessarily support all of the methods, here.
You should consult the data sheet for your device to determine which
commands (passed as the C<Command $command> - an unsigned 8 bit integer)
should be used as they will differ for all devices.


method new(:$device!, :$address!) returns RPi::Device::SMBus


This is the constructor of the class. The named parameters are both
required: C<device> is an the full path (e.g C</dev/i2c-1>) of the
character special device that represents your i2c bus, and C<address>
should be the 7 bit numeric address (i.e. an integer less that 128)
of the device on the bus.


An exception may be thrown if the device cannot be opened, or it does
not support the required ioctls that an i2c device should.


method write-quick(Byte $value) returns Int


This sends a single bit to the device, at the place of the Read/Write
bit returning an integer to indicate the result


This reads a single byte from the device, without the need to specify
a register C<Command>.  This may only be implemented by the simplest
devices, but it can be used as a short hand for C<read-byte-data> but
re-using the previous Command.


method write-byte(Byte $value) returns Int


This is the reverse of read-byte, it will send the single byte to the device.


method read-byte-data(Command $command) returns Int


This reads a single byte from the device register specified by C<$command>.


method write-byte-data(Command $command, Byte $value) returns Int


This writes the single byte C<$value> to the device register C<$command>,
returning an int which will be -1 on failure.


method read-word-data(Command $command) returns Int


This reads the 16 bit word from the register specified by<$command>.


method write-word-data(Command $command, Word $value) returns Int


This writes the 16 bit word C<$value> to the register specified by C<$command> returning an int (which will be -1 on failure.)


method process-call(Command $command, Word $value) returns Int


This writes the 16 bit word C<$value> to the command register C<$command>
and then reads it back (presumably the device will have changed it.)


method read-block-data(Command $command) returns Block


This reads the command register C<$value> and returns the C<Block>
(an array containing up to 32 unsigned 8 bit integers.)



class RPi::Device::SMBus:ver<0.0.4>:auth<github:jonathanstowe>:api<1.0> {

    use NativeHelpers::Array;

    class X::SMBus::Open is Exception {
        has Str $.message;
    }

    class X::SMBus::IO is Exception {
        has Str $.message;
    }

    constant BLOCK_MAX = 32;
    constant HELPER = %?RESOURCES<libraries/i2chelper>.Str;

    subset I2C-Address of Int where * < 128;
    subset DevicePath  of Str where { $_.IO ~~ :e };

    subset Byte    of Int where   {  $_ >= 0 && $_ <= 255 };
    subset Word    of Int where   {  $_ >= 0 && $_ < 65536 };
    subset Command of Int where   {  $_ >= 0 && $_ <= 255 };
    subset Block   of Array where { $_.elems <= 32 && all($_.list) < 256 };

    has I2C-Address $.address is required;
    has DevicePath  $.device  is required;

    has Int $!fd;

    method !fd( --> Int ) {
        $!fd //= do  {
            self!open($!device, $!address);
        }
    }

    sub rpi_dev_smbus_open(Str $file, int32 $address --> int32 ) is native(HELPER) { * }

    method !open(Str $file, Int $address --> Int ) {
        explicitly-manage($file);
        my Int $fd = rpi_dev_smbus_open($file, $address);
        if $fd < 0 {
            X::SMBus::Open.new(message => "Error opening the device").throw;
        }
        $fd;
    }

    sub rpi_dev_smbus_write_quick(int32 $file, uint8 $value --> int32 ) is native(HELPER) { * }

    method write-quick(Byte $value --> Int ) {
        rpi_dev_smbus_write_quick(self!fd, $value);
    }

    sub rpi_dev_smbus_read_byte(int32 $file --> int32 ) is native(HELPER) { * }

    method read-byte( --> Int ) {
        rpi_dev_smbus_read_byte(self!fd);
    }

    sub rpi_dev_smbus_write_byte(int32 $file, uint8 $value --> int32 ) is native(HELPER) { * }

    method write-byte(Byte $value --> Int ) {
        rpi_dev_smbus_write_byte(self!fd, $value);
    }

    sub rpi_dev_smbus_read_byte_data(int32 $file, uint8 $command --> int32 ) is native(HELPER) { * }

    method read-byte-data(Command $command --> Int ) {
        rpi_dev_smbus_read_byte_data(self!fd, $command);
    }

    sub rpi_dev_smbus_write_byte_data(int32 $file, uint8 $command, uint8 $value --> int32 ) is native(HELPER) { * }

    method write-byte-data(Command $command, Byte $value --> Int ) {
        rpi_dev_smbus_write_byte_data(self!fd, $command, $value);
    }

    sub rpi_dev_smbus_read_word_data(int32 $file, uint8 $command --> int32 ) is native(HELPER) { * }

    method read-word-data(Command $command --> Int ) {
        rpi_dev_smbus_read_word_data(self!fd, $command);
    }

    sub rpi_dev_smbus_write_word_data(int32 $file, uint8 $command, uint16 $value --> int32 ) is native(HELPER) { * }

    method write-word-data(Command $command, Word $value --> Int ) {
        rpi_dev_smbus_write_word_data(self!fd, $command, $value);
    }

    sub rpi_dev_smbus_process_call(int32 $file, uint8 $command, uint16 $value --> int32 ) is native(HELPER) { * }

    # writes a Word and returns a value
    method process-call(Command $command, Word $value --> Int ) {
        rpi_dev_smbus_write_word_data(self!fd, $command, $value);
    }

    sub rpi_dev_smbus_read_block_data(int32 $file, uint8 $command, CArray[uint8] $values --> int32 ) is native(HELPER) { * }

    multi method read-block-data(Command $command --> Block ) {
        my CArray[uint8] $out-buf = CArray[uint].new;
        $out-buf[BLOCK_MAX + 1] = 0;

        my $len = rpi_dev_smbus_read_block_data(self!fd, $command, $out-buf);

        if $len < 0 {
            X::SMBus::IO.new(message => "'read_block_data' failed").throw;
        }

        my @array = copy-to-array($out-buf, $len + 1);
        # this is the actual length
        my $ll = @array.shift;
        @array;
    }

    sub rpi_dev_smbus_write_block_data(int32 $file, uint8 $command, uint8 $length, CArray[uint8] $values --> int32 ) is native(HELPER) { * }

    multi method write-block-data(Command $command, Block $block --> Int ) {
        my CArray $buf = copy-to-carray($block, uint8);
        rpi_dev_smbus_write_block_data(self!fd, $command, $block.elems, $buf);
    }

    sub rpi_dev_smbus_read_i2c_block_data(int32 $file, uint8 $command, uint8 $length, CArray[uint8] $values --> int32 ) is native(HELPER) { * }

    multi method read-i2c-block-data(Command $command, Int $length --> Block ) {
        my CArray[uint8] $out-buf = CArray[uint].new;
        $out-buf[BLOCK_MAX + 1] = 0;

        my $len = rpi_dev_smbus_read_i2c_block_data(self!fd, $command, $length, $out-buf);

        if $len < 0 {
            X::SMBus::IO.new(message => "'read_i2c_block_data' failed").throw;
        }

        my @array = copy-to-array($out-buf, $len + 1);
        # this is the actual length
        my $ll = @array.shift;
        @array;
    }

    sub rpi_dev_smbus_write_i2c_block_data(int32 $file, uint8 $command, uint8 $length, CArray[uint8] $values --> int32 ) is native(HELPER) { * }

    multi method write-i2c-block-data(Command $command, Block $block --> Int ) {
        my CArray[uint8] $buf = copy-to-carray($block, uint8);
        rpi_dev_smbus_write_i2c_block_data(self!fd, $command, $block.elems, $buf);
    }

    sub rpi_dev_smbus_block_process_call(int32 $file, uint8 $command, uint8 $length, CArray[uint8] $values --> int32 ) is native(HELPER) { * }

    multi method block-process-call(Command $command, Block $block --> Block ) {
        my CArray[uint8] $buf = copy-to-carray($block, uint8);
        my $len = rpi_dev_smbus_block_process_call(self!fd, $command, $block.elems, $buf);
        if $len < 0 {
            X::SMBus::IO.new(message => "'block_process_call' failed").throw;
        }

        my @array = copy-to-array($buf, $len + 1);
        # this is the actual length
        my $ll = @array.shift;
        @array;

    }

}
# vim: expandtab shiftwidth=4 ft=raku


SMBus

RPi::Device::PiGlow - Interface to the PiGlow board using i2c


=begin code

    use RPi::Device::PiGlow;
    my $pg = RPi::Device::PiGlow.new();

    my $values = [0x01,0x02,0x04,0x08,0x10,0x18,0x20,0x30,0x40,0x50,0x60,0x70,0x80,0x90,0xA0,0xC0,0xE0,0xFF];
    $pg.enable-output;
    $pg.enable-all-leds;
    $pg.write-all-leds($values);
    sleep 10;
    $pg.reset;

=end code


See the L<examples> directory for more ways of using this.


The L<PiGlow from Pimoroni|http://shop.pimoroni.com/products/piglow>
is a small board that plugs in to the Raspberry PI's GPIO header with
18 LEDs on that can be addressed individually via i2c.  This module
uses L<RPi::Device::SMBus|https://github.com/jonathanstowe/RPi-Device-SMBus> to abstract the interface to the device so
that it can be controlled from a Raku programme.  It is assumed that
you have installed the OS packages required to make i2c work and have
configured and tested the i2c appropriately.  The only difference that
seems to affect the PiGlow device is that it only seems to be reported
by C<i2cdetect> if you use the "quick write" probe flag:


(assuming you have a Rev B. Pi - if not you should supply 0 instead
of 1.)  I have no way of knowing the compatibility of the "quick write"
with any other devices you may have plugged in to the Pi, so I wouldn't
recommend doing this with any other devices unless you know that they
won't be adversely affected by "quick write".  The PiGlow has a fixed
address anyway so the information isn't that useful.


A useful quick guide to setting up for the Rapberry Pi 2 can be found
at L<https://blog.robseder.com/2015/04/12/getting-a-piglow-to-work-with-a-raspberry-pi-2/> though
most of that will work for other versions.


The constructor.  This takes two optional attributes which are passed on
directly to the L<RPi::Device::SMBus> constructor:


item

This sets the device path, it defaults to /dev/i2c-1 (assuming a newer
Raspberry PI,) You will want to set this if you are using an older PI or
an OS that creates a different device.


This sets the i2c device address,  this defaults to 0x54.  Unless you have
somehow altered the address you shouldn't need to change this.


This is the L<RPi::Device::SMBus> object we will be using to interact with i2c.
It will be initialised with the attributes described above.  You may want
this if you need to do something to the PiGlow I haven't thought of.


This updates the values set to the LED registers to the LEDs and changes
the display.


This sets the state of the device to active.


method write-all-leds(@values is copy, :$fix) returns Int


This writes the PWM values supplied as an Array  and immediately
calls C<update> to apply the values to the LEDs.
The array must be exactly 18 elements long. If the adverb :fix is
supplied then gamma correction will be applied to the values.


This is convenience to turn off (set to brightness 0) all the LEDs at
once.  It calls C<update> immediately.


method set-leds(@leds, Int $value is copy )


This sets the leds specified in the array C<@leds>
( values 0 - 17 to index the LEDs ) all to the single C<$value> specified.
Gamma adjustment is applied.  This does not call C<update>, this should be
done afterwards in order to update the LED values.


This provides a mapping between the logical order of the leds (indexed
0 - 17 ) to the registers that control them. It returns an Array.


The arrangement of the LEDs can be thought of as being arrange logically
as 6 "rings".  This provides access to the rings indexed 0-5, containing
an array of the led numbers in that ring.


Sets all of the LEDs in the logical C<$ring> indexed 0 - 5 to the
C<$value> specified.  Gamma correction is applied to the value.
This isn't immediately applied to the LEDs, C<update> should be called
after all the changes have been applied.


This returns an Array of Array that reference the LEDs in
each "arm" of the PiGlow.


Sets the LEDs in the specified "arm" of the PiGlow to the specified
value.  Value has gamma correction applied.  Update isn't applied and
the C<update> method should be called when all the required updates have
been performed.


This returns a Hash mapping the names of the coloured LEDs to the groups
of LEDs of that colour.  The delegate C<colours> returns the keys,
C<get-colour-leds> returns the list of LEDs for a named colour.


method get-colour-leds(Colour $colour) returns Array


Returns an array of the LED numbers for the specified Colour.



class RPi::Device::PiGlow:ver<0.0.4>:auth<github:jonathanstowe>:api<1.0> {
    use RPi::Device::SMBus;

    constant CMD_ENABLE_OUTPUT    = 0x00;
    constant CMD_ENABLE_LEDS      = 0x13;
    constant CMD_ENABLE_LEDS_1    = 0x13;
    constant CMD_ENABLE_LEDS_2    = 0x14;
    constant CMD_ENABLE_LEDS_3    = 0x15;
    constant CMD_SET_PWM_VALUES   = 0x01;
    constant CMD_SET_PWM_VALUE_1  = 0x01;
    constant CMD_SET_PWM_VALUE_2  = 0x02;
    constant CMD_SET_PWM_VALUE_3  = 0x03;
    constant CMD_SET_PWM_VALUE_4  = 0x04;
    constant CMD_SET_PWM_VALUE_5  = 0x05;
    constant CMD_SET_PWM_VALUE_6  = 0x06;
    constant CMD_SET_PWM_VALUE_7  = 0x07;
    constant CMD_SET_PWM_VALUE_8  = 0x08;
    constant CMD_SET_PWM_VALUE_9  = 0x09;
    constant CMD_SET_PWM_VALUE_10 = 0x0A;
    constant CMD_SET_PWM_VALUE_11 = 0x0B;
    constant CMD_SET_PWM_VALUE_12 = 0x0C;
    constant CMD_SET_PWM_VALUE_13 = 0x0D;
    constant CMD_SET_PWM_VALUE_14 = 0x0E;
    constant CMD_SET_PWM_VALUE_15 = 0x0F;
    constant CMD_SET_PWM_VALUE_16 = 0x10;
    constant CMD_SET_PWM_VALUE_17 = 0x11;
    constant CMD_SET_PWM_VALUE_18 = 0x12;
    constant CMD_UPDATE           = 0x16;
    constant CMD_RESET            = 0x17;

    constant NUM_LEDS             = 18;

    subset Ring     of Int where { $_ >= 0 && $_ <= 5 };
    subset Arm      of Int where { $_ >= 0 && $_ <= 2 };
    subset Colour   of Str where { get-colour-table{$_}:exists };

    has RPi::Device::SMBus::DevicePath  $.i2c-bus-device-path = '/dev/i2c-1';
    has RPi::Device::SMBus::I2C-Address $.i2c-device-address  = 0x054;

    has RPi::Device::SMBus              $.device-smbus;

    method device-smbus( --> RPi::Device::SMBus ) handles <write-byte-data write-block-data write-i2c-block-data> {
        $!device-smbus //= do  {
            RPi::Device::SMBus.new(
                address => $!i2c-device-address,
                device  =>  $!i2c-bus-device-path
            );
        }
    }

    has @!led-bank-enable-registers = CMD_ENABLE_LEDS_1, CMD_ENABLE_LEDS_2, CMD_ENABLE_LEDS_3;

    method update( --> Int ) {
        self.write-byte-data(CMD_UPDATE, 0xFF);
    }

    method enable-output( --> Int ) {
        self.write-byte-data(CMD_ENABLE_OUTPUT, 0x01);
    }

    method enable-all-leds( --> Int ) {
        self.write-i2c-block-data(CMD_ENABLE_LEDS, [0xFF, 0xFF, 0xFF]);
    }

    method write-all-leds(@values is copy, :$fix --> Int ) {
        if $fix {
            @values = self.gamma-fix-values(@values);
        }
        self.write-i2c-block-data(CMD_SET_PWM_VALUES, @values);
        self.update;
    }

    method all-off( --> Int ) {

        my @vals = 0 xx NUM_LEDS;
        self.write-all-leds(@vals);
    }

    method set-leds(@leds, Int $value is copy ) {
        $value = self.map-gamma($value);
        for @leds -> $led {
            self.write-byte-data(self.get-led-register($led), $value);
        }
    }

    has @.led-table handles ( 'get-led-register' => 'AT-POS' ) = get-led-table();

    sub get-led-table( --> Array ) {
        return [
             CMD_SET_PWM_VALUE_7,
             CMD_SET_PWM_VALUE_8,
             CMD_SET_PWM_VALUE_9,
             CMD_SET_PWM_VALUE_6,
             CMD_SET_PWM_VALUE_5,
             CMD_SET_PWM_VALUE_10,
             CMD_SET_PWM_VALUE_18,
             CMD_SET_PWM_VALUE_17,
             CMD_SET_PWM_VALUE_16,
             CMD_SET_PWM_VALUE_14,
             CMD_SET_PWM_VALUE_12,
             CMD_SET_PWM_VALUE_11,
             CMD_SET_PWM_VALUE_1,
             CMD_SET_PWM_VALUE_2,
             CMD_SET_PWM_VALUE_3,
             CMD_SET_PWM_VALUE_4,
             CMD_SET_PWM_VALUE_15,
             CMD_SET_PWM_VALUE_13,
          ];
    }

    has @.ring-table;

    method ring-table( --> Array ) {
        if @!ring-table.elems == 0 {
            for ^6 -> $led  {
                for ^3 -> $arm {
                    my $led-no = self.get-arm-leds($arm)[$led];
                    @!ring-table[$led].push($led-no);
                }
            }
        }
        return @!ring-table;
    }

    method get-ring-leds(Ring $ring --> Array ) {
        self.ring-table[$ring].Array
    }


    method set-ring(Ring $ring, $value) {
        my @ring-leds = self.get-ring-leds($ring);
        self.set-leds(@ring-leds, $value);
    }

    has @.arm-table = get-arm-table();

    sub get-arm-table( --> Array ) {
        return [
                [0,1,2,3,4,5],
                [6,7,8,9,10,11],
                [12,13,14,15,16,17]
               ];
    }

    method get-arm-leds(Arm $arm) returns Array {
        self.arm-table[$arm].Array;
    }


    method set-arm(Arm $arm, $value ) {
        my @arm-leds = self.get-arm-leds($arm);
        self.set-leds(@arm-leds, $value);
    }

    has %.colour-table handles ( 'colours' => 'keys' ) = get-colour-table();

    sub get-colour-table( --> Hash ) {
        return {
                    white   => [5,11,17],
                    blue    => [4,10,16],
                    green   => [3,9,15],
                    yellow  => [2,8,14],
                    orange  => [1,7,13],
                    red     => [0,6,12]     ,
               };
    }

    method get-colour-leds(Colour $colour --> Array ) {
        self.colour-table{$colour}.Array;
    }


    method set-colour(Colour $colour, $value) {
        my @colour-leds = self.get-colour-leds($colour);
        self.set-leds(@colour-leds, $value);
    }

    has @.gamma-table handles ( 'map-gamma' => 'AT-POS' ) = get-gamma-table();

    sub get-gamma-table( --> Array ) {
        return [
            0,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
            1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
            1,   1,   1,   1,   2,   2,   2,   2,   2,   2,   2,   2,   2,   2,
            2,   2,   2,   2,   2,   2,   2,   2,   2,   3,   3,   3,   3,   3,
            3,   3,   3,   3,   3,   3,   3,   3,   4,   4,   4,   4,   4,   4,
            4,   4,   4,   4,   4,   5,   5,   5,   5,   5,   5,   5,   5,   6,
            6,   6,   6,   6,   6,   6,   7,   7,   7,   7,   7,   7,   8,   8,
            8,   8,   8,   8,   9,   9,   9,   9,   10,  10,  10,  10,  10,  11,
            11,  11,  11,  12,  12,  12,  13,  13,  13,  13,  14,  14,  14,  15,
            15,  15,  16,  16,  16,  17,  17,  18,  18,  18,  19,  19,  20,  20,
            20,  21,  21,  22,  22,  23,  23,  24,  24,  25,  26,  26,  27,  27,
            28,  29,  29,  30,  31,  31,  32,  33,  33,  34,  35,  36,  36,  37,
            38,  39,  40,  41,  42,  42,  43,  44,  45,  46,  47,  48,  50,  51,
            52,  53,  54,  55,  57,  58,  59,  60,  62,  63,  64,  66,  67,  69,
            70,  72,  74,  75,  77,  79,  80,  82,  84,  86,  88,  90,  91,  94,
            96,  98,  100, 102, 104, 107, 109, 111, 114, 116, 119, 122, 124, 127,
            130, 133, 136, 139, 142, 145, 148, 151, 155, 158, 161, 165, 169, 172,
            176, 180, 184, 188, 192, 196, 201, 205, 210, 214, 219, 224, 229, 234,
            239, 244, 250, 255,
        ];
    }

    method gamma-fix-values(@values is copy --> Array ) {
        @values = @values.map({ self.map-gamma($_) });
        return @values;
    }

    method reset(--> Int ) {
        self.write-byte-data(CMD_RESET, 0xFF);
    }

}
# vim: expandtab shiftwidth=4 ft=raku


PiGlow

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

RPi::Device::PiGlow

Synopsis

Description

Installation

Support

Licence

RPi::Device::PiGlow v0.0.5

Authors

License

Dependencies

Test Dependencies

Provides

Documentation