head

Image

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

unit class Linux::Joystick:ver<0.0.3>:auth<zef:thundergnat>;

use experimental :pack;

# Joysticks generally show up in the /dev/input/ directory as js(n) where n is
# the number assigned by the OS.

sub devices is export {
    my @devices;
    for '/dev/input/', '/dev/' -> $path {
        if $path.IO.e {
            @devices.append: $path.IO.dir.grep( *.contains('/js') ).sort;
        }
    }
    print 'No ' unless +@devices;
    say "active Joystick devices";
    .path.say for @devices;
    @devices;
}

class Linux::Joystick {
    has $.device;
    has &.callback is rw = sub { };
    has %.config;
    has %.event;
    has $!js;

    method TWEAK {
        # need a device
        unless $!device and $!device.IO.e {
            $!device //= 'null device';
            note "<{$!device}> not found.\nNeed to provide a path to an active device, try running" ~
            " devices() to see which joysticks are available, see below.\n";
            devices();
            exit ;
        }

        $!js = $!device.IO.open(:bin).Supply(:8size);
        start react { whenever $!js { $!js.act: { get-js-event(self, $_, self.callback) } } }
        sleep .5; # do a short delay tp allow driver to initialize
    }

    sub get-js-event ($j, $ev, &callback ) {

        # 32 bit timestamp milliseconds. Allows easy checking for "double-click" button presses
        $j.event<timestamp> = $ev.subbuf(0, 4).reverse.unpack('N');

        # 16 bit (signed int16) value of current control
        $j.event.<value> = (my $v = $ev.subbuf(4, 2).unpack('S')) > 32767 ?? -65536 + $v !! $v;

        # Two 8 bit integers, current event: control type, and control ID
        ($j.event.<type>, $j.event.<number>) = $ev.subbuf(6).unpack('CC');

        # Process the event
        given $j.event.<type> +& 3  { # enumeration of control inputs
            when 1 { $j.config.<button>[$j.event.<number>] = $j.event.<value> }
            when 2 { $j.config.<axis>[$j.event.<number>] = $j.event.<value> }
        }
        callback unless $j.event.<type> +& 128; # unless initializing
    }
}




=begin code :lang<raku>

use Linux::Joystick;

my $joystick = Linux::Joystick.new(
    :device('/path/to/mydevice'),
    :callback(&optional-callback)
);

=end code


Linux::Joystick - a simple interface to the most common Linux joystick driver.


(Also tested and working under Mac OSX.)


Sets up an asynchronous event stream reading events from the joystick in real
time.  Allows you to provide a callback routine which will execute every time an
event  is received.


The callback routine is rewritable and may be changed without restarting the
joystick driver.


Needs to be initilized with a path to a valid, active joystick or joystick-like
device. (An Xbox controller will work.) Optionally takes a callable routine to be
executed every time an event is received.


An exported routine: C<devices()> can be used to find and list available joystick
devices.


Exports two hashes. C<$joystick.config> and C<$joystick.event>.


C<$joystick.config> contains the enumerated inputs and their present value.
Assuming your joystick has 12 buttons and 6 axes (Like a Logitech Extreme 3D for
instance.) The enumerated button values will be in C<$joystick.config<button>[0]>
through C<$joystick.config<button>[11]>. The enumerated axes will be in
C<$joystick.config<axis>[0]> through C<$joystick.config<axis>[5]> .


You may also access events directly. C<$joystick.event> will hold the values from
the last event processed.


item

Button values can only be 0 (up) or 1 (pressed). Axis values can (though not
necessarily always do) range from -32767 to 32767. In general, even numbered
axes operate in the vertical (y) axis with smaller numbers being higher up and
larger being further down. Odd numbered axes usually operate in a horizontal (x)
axis. Smaller values to the left, larger to the right.


If you end up tapping a SIGINT signal, the joystick stream won't close until it
sees one more joystick event, the joystick is unplugged, or you send another
different terminate event.


See the L</examples/joystick.p6|https://github.com/thundergnat/Linux-Joystick/blob/master/examples/joystick.p6> script to see how that might be done.


This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


Joystick

An array of objects of this type are returned by the method C<fuser> in
L<doc:Linux::Fuser>.  It describes a single process that has the requested
file open.


Because it has to read special files that may only be readable by the user that
owns the process it may not work as expected for users other than the superuser.


Typically objects of this type will be created as needed by C<fuser> and there
should be no need for user code to construct new objects.


use v6;

use nqp;
use Linux::Fuser::FileDescriptor;
# For the time being
use System::Passwd;



Linux::Fuxer::Procinfo - describe the process that has a file opened.


NAME

DESCRIPTION

There are no public methods only read-only attributes.


ATTRIBUTES


class Linux::Fuser::Procinfo {
    #| The process ID of the process that has the file open
    has Int $.pid;
    #| The username of the user who owns the process
    has Str $.user;
    #| An array of the parts of the command that this process represents, i.e the argv
    #| as passed to the system execve()
    has Str @.cmd;
    #| A L<doc:Linux::Fuser::FileDescriptor> that describes the file as the process
    #| has it opened.
    has Linux::Fuser::FileDescriptor $.filedes;

    #| The L<doc:IO::Path> describing the /proc entry
    #| This is passed to the constructor
    has IO::Path $.proc-file;
    #| The L<doc:IO::Path> that corresponds to the /proc/<pid>/fd entry for the file
    has IO::Path $.fd-file;


    submethod BUILD(:$!proc-file, :$!fd-file) {
        $!pid = $!proc-file.basename + 0;
        my $cmdline = $!proc-file.append('cmdline');
        # rather awkward locution but basically cmdline is a copy of the argv
        # as got to execve with the \0s and everything
        my $cmd_fh = $cmdline.open(:bin);
        @!cmd = $cmd_fh.read(4096).decode.split("\0");
        $!filedes = Linux::Fuser::FileDescriptor.new(proc-file => $!proc-file, fd-file => $!fd-file);

        if ((my $uid = self!lstat_uid()).defined ) {
            $!user = get-user-by-uid($uid).username;
        }
    }

    #| supply the required missing part of lstat() to get the owner of the FD
    method !lstat_uid() {
        nqp::p6box_i(nqp::stat(nqp::unbox_s($!fd-file.Str), nqp::const::STAT_UID));
    }
}
# vim: expandtab shiftwidth=4 ft=raku


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

Linux::Fuser

image i_github_com_jonathanstowe_raku_linux_fuser_workflows_ci_badge_svg not found

Description

Installation

Support

Licence

Linux::Fuser v0.0.15

Authors

License

Dependencies

Test Dependencies

Provides

Documentation