Well, I confirmed that what I was trying to do is definitely possible. By adding the following code to the external application, somewhat simulating what the original function was doing:

void interruptTest(void(*function)(void)){
    isrFunctions[1] = function;
    isrFunctions[1]();
}
[download]

...and then simplifying my code to use this new function:

use warnings;
use strict;

use Inline ('C' => 'DATA', libs => '-lwiringPi');

# direct call

callback();

# extern call

testing();

sub p_callback {
    print "in perl callback\n";
}

__DATA__
__C__

#include <stdlib.h>
#include <stdio.h>
#include <wiringPi.h>

void testing();
void callback();

void callback(){
   dSP;
    PUSHMARK(SP);
    PUTBACK;

    call_pv("p_callback", G_DISCARD|G_NOARGS);

    FREETMPS;
    LEAVE;         

}

void testing(){
    interruptTest(&callback);
}
[download]

I get no segfaults, and the perl callback is called in both instances (internal and external). So its not that the external code doesn't know how to process the callback, it has to be something to do with what's happening in the original function I was sending it into. There's forking happening, and then the callback is executed when an interrupt happens, so I'll keep playing.

For completeness sake, I'm posting the relevant code that now has fixed my original problem. I can now use an external library that has ISR (Interrupt Service Routine) capability.

What I needed to do was allow a user to send in a Perl code reference, and then have the C interrupt handler dynamically call that user-supplied sub when the interrupt occurred.

XS code that sets up the interrupt through the external lib:

void interruptHandler();
int setInterrupt(int pin, int edge, char *callback);

char *perl_callback;
PerlInterpreter *mine;

void interruptHandler(){
    PERL_SET_CONTEXT(mine);

    dSP;
    PUSHMARK(SP);
    PUTBACK;

    call_pv(perl_callback, G_DISCARD|G_NOARGS);

    FREETMPS;
    LEAVE;
}

int setInterrupt(int pin, int edge, char *callback){
    perl_callback = callback;
    int interrupt = wiringPiISR(pin, edge, &interruptHandler);
    return interrupt;
}

# XS

int
setInterrupt(pin, edge, callback)
    int pin
    int edge
    char *callback

void
interruptHandler()
[download]

Perl module code that calls into the XS:

sub set_interrupt {
    shift if @_ == 4;
    my ($pin, $edge, $callback) = @_;
    setInterrupt($pin, $edge, $callback);
}
[download]

...and finally a basic test script:

use warnings;
use strict;

use RPi::WiringPi;
use RPi::WiringPi::Constant qw(:all);

my $pi = RPi::WiringPi->new();
my $pin = $pi->pin(27);

RPi::WiringPi::Core::set_interrupt(
    $pin->num, 
    EDGE_RISING, 
    'pin_27_edge_rise'
);

$pin->mode(INPUT);

sleep 10;

# manually change the pin state here to trigger
# interrupt

$pi->cleanup;

sub pin_27_edge_rise {
    print "pin 27 edge rise callback...\n";
    # do other stuff
}
[download]

I see where you declare PerlInterpreter *mine to hold the Perl context, but where you assign it?

In his linked example, BrowserUk has:

void setCallback( SV *cb1, SV* cb2, SV *cb3, SV *cb4 ) {
    saved = Perl_get_context();
[download]

but I don't see an equivalent in your code.

I can confirm that you have to run

mine = Perl_get_context();
[download]

before you can use this. The run of

dSP;
[download]

just segfaults if

mine
[download]

have not been set via

mine = Perl_get_context();
[download]

I call on initialisation of my module a XS function which does does do


mine = Perl_get_context();
[download]

and verify that mine is not NULL before trying to call a perl function.

All I needed is the following to get it working, and call the function "functionname" within of the module I called "setcallback" from.
The use in C:

void dorunperlfunction() {
   if (mine) {
      PERL_SET_CONTEXT(mine);
      dSP;
      ENTER;
      SAVETMPS;
      PUSHMARK(SP);
      PUTBACK;
      call_pv("functionname", G_DISCARD|G_NOARGS);
      FREETMPS;
      LEAVE;
   }
[download]

The initialisation in XS(!):

PerlInterpreter * mine = NULL;
...
void
setcallback()
   CODE:
      ...
      mine = Perl_get_context();
      ...
[download]

I'm surprised no-one has commented on this yet: are you really attempting to call perl code from an ISR (interrupt service routine)? Perl does allow "PERL_SIGNALS=unsafe", but generally, signal handling is deferred for good reasons.

What sort of code do you need to invoke from an interrupt handler? Can't you just use the regular dispatch via $SIG{USR1} or something?

Essentially, an external program is handling the interrupts within threads... I just want to be able to have user-generated perl code executed when the interrupt is triggered.

I've found that the problem isn't necessarily with the wiringPi software. I've recreated the issue without external libraries. The problem seems to be with threads. The following works fine, until I uncomment the XS code within the wrapper() function...

use warnings;
use strict;

use Inline (C => 'DATA', libs => '-lpthread');

create_thread('blah');

sub blah {
    print "perl callback\n";
}

__DATA__
__C__

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

void wrapper(void *sub_name_ptr){
    char *sub_name = (char *)sub_name_ptr;

    printf("threaded ok, sub: %s\n", sub_name);

    /*
        dSP;
        PUSHMARK(SP);
        PUTBACK;

        call_pv(sub_name, G_DISCARD|G_NOARGS);
        FREETMPS;
        LEAVE;
    */

    return NULL;
}

int create_thread(char *subname){   
    pthread_t sub_thread;
 
   
    if(pthread_create(&sub_thread, NULL, wrapper, subname)) {
        fprintf(stderr, "Error creating thread\n");
        return 1;
    }
    
    if(pthread_join(sub_thread, NULL)) {
        fprintf(stderr, "Error joining thread\n");
        return 2;
    }

    return 0;
}
[download]

Under threads, perl code needs the appropriate context. If you callback to code referenced from one thread whilst running under another, you will have the wrong context and crash.

Read down from here, it may help. There is lots of good information, but it evolves out over a long back&forth thread.

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority". I knew I was on the right track :)

In the absence of evidence, opinion is indistinguishable from prejudice.

   PUTBACK;
   FREETMPS;                       /* free that return value        */
   LEAVE;                       /* ...and the XPUSHed "mortal" args.*/
[download]

Do you mean within callback()? I put those lines before and after the call to the actual perl sub, but both cases still result in segfault.

This is example I'm looking at https://metacpan.org/pod/perlembed#Fiddling-with-the-Perl-stack-from-your-C-program and I think you could copy this example and turn it into void callback(),

something like

Read more... (1365 Bytes)

Yes , I understand perlcall gives simpler example like you have , but its what I would try, to see if anything sticks :D