Hi all,
After a long time of hard and intensive work, my first book, 'Digital Electronics for Musicians' is out!
The book focuses on Pd patching and Arduino programming, and in the communication between the two platforms, creating musical interfaces. Some projects incorporate embedded computers, focusing on the Raspberry Pi, but giving generic information on this subject. Hopefully some people will find this helpful and fun!
http://www.apress.com/9781484215845?gtmf=s

On Amazon you can have a glance at some of its contents!
http://www.amazon.com/Digital-Electronics-Musicians-Alexandros-Drymonitis/dp/1484215842/ref=sr_1_1?s=books&ie=UTF8&qid=1450708668&sr=1-1&keywords=digital+electronics+for+musicians

Cool...excellent in fact. Will start with 1 issue and go 1 at a time...

Main behaviour is a single click/double click/long hold. ie For midi sustain, a quick single click enables a filter which allows only note on values to play midi notes (for sustained atmoshpheres played from a midi guitar). Anything longer than a quick click is a standard momentary sustain pedal. A double click resets the pedal action and sends an 'all notes off' to clear everything.
I was planning to use this in a browser so I used an active X timer so it would be async to the rest of the script. Hope I have added enough comments to explain;

Insert Code Here
Case 64
    'Case CC 64 = sustain message from floorboard
    'Dat1 = Midi message type+channel
    'Dat2 = message value
    
    'default action is send cc64 to instrument out ie Dat2 = 127 and begin sustain regardless of note off filter/sustain action

    If Dat2>0 Then mox.OutputMidiMsg InstOut, &hB0, 64, 127
    'SC is prefix: SingleClick
    'Check if its the first trigger in timer sequence and timer has been fired
    If SCTiming = 1 then
        'Test how many pedal downs have occured during timer period
        If Dat1 = SCOldDat1 THEN
            SCClkCnt = SCClkCnt+1
        End If
    Else
        'Waiting for Single Click Pedal Up
        If WaitForSCPU=1 Then
            If (SCOldDat1=Dat1 AND Dat2=0) Then
                'Long Hold Action - cc64 sustain off
                mox.OutputMidiMsg InstOut, &hB0, 64, 0
                'Clear wait flag
                WaitForSCPU = 0
            End If
        Else
            'fresh trigger
            'sc and dc are single/double click actions that are executed as strings according to timer
            sc="FilterMGNoteOff = FilterMGNoteOff XOR True : mox.OutputMidiMsg InstOut, &hB0, 64, 0"
            ' PUREDATA NOTE: couldnt see any XOR functions?
            dc="mox.OutputMidiMsg InstOut, &hB0, &h7B, &h7F : FilterMGNoteOff = False : mox.OutputMidiMsg InstOut, &hB0, 64, 0"
            'SCTiming is a flag to indicate timer has fired
            SCTiming = 1
            SCTimer.enabled = true
            SCTimer.Duration = 400
            'set the click count to 1 (ie pedal down of 127 has ocurred)
            SCClkCnt = 1
        End If
    End If
    'Single Click previous value used for comparison/click count
    SCOldDat1 = Dat1

Insert Code Here

And here is the timer sink/sub;

Insert Code Here
Sub SC_Timer
    SCTiming=0
    'Do Timer results here
    If (SCClkCnt=3 OR SCClkCnt=4) Then
        'DC Behaviour
        Execute(dc)
    Else
        If SCClkCnt=2 Then
            'msgbox "sc"
            'SC Behaviour
            Execute(sc)
        Else
            If SCClkCnt=1 Then
                'Wait for pedal up
                'msgbox "pedal up"
                WaitForSCPU=1
            End If
        End If
    End If
    'Reset ClkCnt
    SCClkCnt=0
    SCTimer.enabled = false
End Sub

Hope that helps explain

The above example is a bit parametric in that it feeds strings to the sub. This type of module is used throughout the script so Im totally open to simplifying it/modding to make it better in PD...which, from what I have seen, looks like it should be able to do.

If I can get all the previous code to translate, would like to add a control panel showing the fcb with the the current status/values of footswitches on screen, or even just just plug a tablet on the front of the controller for the future.

Many thanks
Mark

@nau Hi, same boat (I don't know much about Pd internal functions & pthread), but maybe you can try to see if this external (really similar to my template, but this time to fetch real data for my HiCu project).

Look for m_clock / m_interval and clock_delay.

// ==============================================================================
//  gac.c
//  
//  pd-Interface to [ 11h11 | gac ]
//  Adapted by: Patrick Sebastien Coulombe
//  Website:    http://www.workinprogress.ca/guitare-a-crayon
//
//  Original Author:    Michael Egger
//  Copyright:  2007 [ a n y m a ]
//  Website:    http://gnusb.sourceforge.net/
//  
//  License:    GNU GPL 2.0 www.gnu.org
//  Version:    2009-04-11
// ==============================================================================
// ==============================================================================

#include "m_pd.h"
#include <usb.h> //http://libusb-win32.sourceforge.net
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "pthread.h"

#include "../common/gac_cmds.h"


// ==============================================================================
// Constants
// ------------------------------------------------------------------------------
#define USBDEV_SHARED_VENDOR        0x16c0  /* VOTI */
#define USBDEV_SHARED_PRODUCT       0x05dc  /* Obdev's free shared PID */
#define DEFAULT_CLOCK_INTERVAL      34      /* ms */
#define OUTLETS                     11
#define USBREPLYBUFFER              14

unsigned char buffer[USBREPLYBUFFER]; //accessible everywhere

// ==============================================================================
// Our External's Memory structure
// ------------------------------------------------------------------------------
typedef struct _gac             // defines our object's internal variables for each instance in a patch
{
    t_object        p_ob;                   // object header - ALL pd external MUST begin with this...
    usb_dev_handle  *dev_handle;            // handle to the gac usb device
    void            *m_clock;               // handle to our clock
    double          m_interval;             // clock interval for polling edubeat
    double          m_interval_bak;         // backup clock interval for polling edubeat
    int             is_running;             // is our clock ticking?
    void            *outlets[OUTLETS];      // handle to the objects outlets
    int             x_verbose;
    pthread_attr_t  gac_thread_attr;
    pthread_t       x_threadid;
} t_gac;

void *gac_class;                    // global pointer to the object class - so pd can reference the object 


// ==============================================================================
// Function Prototypes
// ------------------------------------------------------------------------------
void *gac_new(t_symbol *s);
void gac_assist(t_gac *x, void *b, long m, long a, char *s);
void gac_bang(t_gac *x);                
void gac_bootloader(t_gac *x);

static int usbGetStringAscii(usb_dev_handle *dev, int ndex, int langid, char *buf, int buflen);
void find_device(t_gac *x);

// =============================================================================
// Threading
// ------------------------------------------------------------------------------
static void *usb_thread_read(void *w)
{
    t_gac *x = (t_gac*) w;
    int nBytes;
    
    while(1) {
        pthread_testcancel();
            if (!(x->dev_handle)) find_device(x);
            else {
                    nBytes = usb_control_msg(x->dev_handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, 
                                        EDUBEAT_CMD_POLL, 0, 0, (char *)buffer, sizeof(buffer), DEFAULT_CLOCK_INTERVAL);
                    if(x->x_verbose)post("thread read %i bytes", nBytes);
                    //post("%i b", nBytes);
            }
    }
    return 0;
}

static void usb_thread_start(t_gac *x) {
    // create the worker thread
    if(pthread_attr_init(&x->gac_thread_attr) < 0)
    {
       error("gac: could not launch receive thread");
       return;
    }
    if(pthread_attr_setdetachstate(&x->gac_thread_attr, PTHREAD_CREATE_DETACHED) < 0)
    {
       error("gac: could not launch receive thread");
       return;
    }
    if(pthread_create(&x->x_threadid, &x->gac_thread_attr, usb_thread_read, x) < 0)
    {
       error("gac: could not launch receive thread");
       return;
    }
    else
    {
       if(x->x_verbose)post("gac: thread %d launched", (int)x->x_threadid );
    }
}

//--------------------------------------------------------------------------
// - Message: bootloader
//--------------------------------------------------------------------------
void gac_bootloader(t_gac *x)
{
    int cmd;
    int nBytes;
    unsigned char bootloaderbuffer[8];
    
    cmd = 0;
    
    cmd = EDUBEAT_CMD_START_BOOTLOADER;
    if (!(x->dev_handle)) find_device(x);
    else {
        nBytes = usb_control_msg(x->dev_handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, 
                            cmd, 0, 0, (char *)bootloaderbuffer, sizeof(bootloaderbuffer), DEFAULT_CLOCK_INTERVAL);
    }
}

//--------------------------------------------------------------------------
// - Message: bang  -> poll gac
//--------------------------------------------------------------------------
void gac_bang(t_gac *x) {
    int                 i,n;
    int                 replymask,replyshift,replybyte;
    int                 temp;
    
    for (i = 0; i < OUTLETS; i++) {
        temp = buffer[i];
        
        switch(i) {
            case 0:
                replybyte = buffer[8];
                replyshift = ((0 % 4) * 2);
                replymask = (3 << replyshift);
                temp = temp * 4 + ((replybyte & replymask) >> replyshift);
            break;
            case 1:
                replybyte = buffer[8];
                replyshift = ((1 % 4) * 2);
                replymask = (3 << replyshift);
                temp = temp * 4 + ((replybyte & replymask) >> replyshift);
            break;
            case 2:
                replybyte = buffer[8];
                replyshift = ((2 % 4) * 2);
                replymask = (3 << replyshift);
                temp = temp * 4 + ((replybyte & replymask) >> replyshift);
            break;
            case 3:
                replybyte = buffer[8];
                replyshift = ((3 % 4) * 2);
                replymask = (3 << replyshift);
                temp = temp * 4 + ((replybyte & replymask) >> replyshift);
            break;
            case 4:
                replybyte = buffer[9];
                replyshift = ((0 % 4) * 2);
                replymask = (3 << replyshift);
                temp = temp * 4 + ((replybyte & replymask) >> replyshift);
            break;
            case 5:
                replybyte = buffer[9];
                replyshift = ((1 % 4) * 2);
                replymask = (3 << replyshift);
                temp = temp * 4 + ((replybyte & replymask) >> replyshift);
            break;
            case 6:
                replybyte = buffer[9];
                replyshift = ((2 % 4) * 2);
                replymask = (3 << replyshift);
                temp = temp * 4 + ((replybyte & replymask) >> replyshift);
            break;
            
            case 8:
                temp = buffer[10];
                replybyte = buffer[13];
                replyshift = ((0 % 4) * 2);
                replymask = (3 << replyshift);
                temp = temp * 4 + ((replybyte & replymask) >> replyshift);
            break;
            case 9:
                temp = buffer[11];
                replybyte = buffer[13];
                replyshift = ((1 % 4) * 2);
                replymask = (3 << replyshift);
                temp = temp * 4 + ((replybyte & replymask) >> replyshift);
            break;
            case 10:
                temp = buffer[12];
                replybyte = buffer[13];
                replyshift = ((2 % 4) * 2);
                replymask = (3 << replyshift);
                temp = temp * 4 + ((replybyte & replymask) >> replyshift);
            break;
        }
        outlet_float(x->outlets[i], temp);
    }
            
}

//--------------------------------------------------------------------------
// - The clock is ticking, tic, tac...
//--------------------------------------------------------------------------
void gac_tick(t_gac *x) { 
    clock_delay(x->m_clock, x->m_interval);     // schedule another tick
    gac_bang(x);                                // poll the edubeat
} 


//--------------------------------------------------------------------------
// - Object creation and setup
//--------------------------------------------------------------------------
int gac_setup(void)
{
    gac_class = class_new ( gensym("gac"),(t_newmethod)gac_new, 0, sizeof(t_gac),   CLASS_DEFAULT,0);
    // Add message handlers
    class_addbang(gac_class, (t_method)gac_bang);
    class_addmethod(gac_class, (t_method)gac_bootloader, gensym("bootloader"), A_DEFSYM,0);
    post("bald-approved gac version 0.1",0);
    return 1;
}

//--------------------------------------------------------------------------
void *gac_new(t_symbol *s)      // s = optional argument typed into object box (A_SYM) -- defaults to 0 if no args are typed
{
    t_gac *x;                                   // local variable (pointer to a t_gac data structure)
    x = (t_gac *)pd_new(gac_class);          // create a new instance of this object
    x->m_clock = clock_new(x,(t_method)gac_tick);
    x->x_verbose = 0;

    x->m_interval = DEFAULT_CLOCK_INTERVAL;
    x->m_interval_bak = DEFAULT_CLOCK_INTERVAL;
    
    x->dev_handle = NULL;
    int i;
    
    // create outlets and assign it to our outlet variable in the instance's data structure
    for (i=0; i < OUTLETS; i++) {
        x->outlets[i] = outlet_new(&x->p_ob, &s_float);
    }   

    usb_thread_start(x); //start polling the device
    clock_delay(x->m_clock,0.); //start reading the buffer

    return x; // return a reference to the object instance 
}

//--------------------------------------------------------------------------
// - Object destruction
//--------------------------------------------------------------------------
void gac_free(t_gac *x)
{
    if (x->dev_handle) usb_close(x->dev_handle);
    freebytes((t_object *)x->m_clock, sizeof(x->m_clock));
        while(pthread_cancel(x->x_threadid) < 0)
            if(x->x_verbose)post("gac: killing thread\n");
        if(x->x_verbose)post("gac: thread canceled\n");
            
}

//--------------------------------------------------------------------------
// - USB Utility Functions
//--------------------------------------------------------------------------
static int  usbGetStringAscii(usb_dev_handle *dev, int ndex, int langid, char *buf, int buflen)
{
char    asciibuffer[256];
int     rval, i;

    if((rval = usb_control_msg(dev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) + ndex, langid, asciibuffer, sizeof(asciibuffer), 1000)) < 0)
        return rval;
    if(asciibuffer[1] != USB_DT_STRING)
        return 0;
    if((unsigned char)asciibuffer[0] < rval)
        rval = (unsigned char)asciibuffer[0];
    rval /= 2;
    /* lossy conversion to ISO Latin1 */
    for(i=1;i<rval;i++){
        if(i > buflen)  /* destination buffer overflow */
            break;
        buf[i-1] = asciibuffer[2 * i];
        if(asciibuffer[2 * i + 1] != 0)  /* outside of ISO Latin1 range */
            buf[i-1] = '?';
    }
    buf[i-1] = 0;
    return i-1;
}

//--------------------------------------------------------------------------
void find_device(t_gac *x) {
    usb_dev_handle      *handle = NULL;
    struct usb_bus      *bus;
    struct usb_device   *dev;
    
    usb_init();
    usb_find_busses();
    usb_find_devices();
     for(bus=usb_busses; bus; bus=bus->next){
        for(dev=bus->devices; dev; dev=dev->next){
            if(dev->descriptor.idVendor == USBDEV_SHARED_VENDOR && dev->descriptor.idProduct == USBDEV_SHARED_PRODUCT){
                char    string[256];
                int     len;
                handle = usb_open(dev); /* we need to open the device in order to query strings */
                if(!handle){
                    error ("Warning: cannot open USB device: %s", usb_strerror());
                    continue;
                }
                /* now find out whether the device actually is gac */
                len = usbGetStringAscii(handle, dev->descriptor.iManufacturer, 0x0409, string, sizeof(string));
                if(len < 0){
                    post("gac: warning: cannot query manufacturer for device: %s", usb_strerror());
                    goto skipDevice;
                }
                post("::::::%s", string);
                
                if(strcmp(string, "11h11") != 0)
                    goto skipDevice;
                len = usbGetStringAscii(handle, dev->descriptor.iProduct, 0x0409, string, sizeof(string));
                if(len < 0){
                    post("gac: warning: cannot query product for device: %s", usb_strerror());
                    goto skipDevice;
                }
                if(strcmp(string, "Gac") == 0)
                    break;
                skipDevice:
                usb_close(handle);
                handle = NULL;
            }
        }
        if(handle)
            break;
    }
    
    if(!handle){
        post("Could not find USB device 11h11/gac");
        x->dev_handle = NULL;
    } else {
         x->dev_handle = handle;
         post("Found USB device 11h11/gac");
    }
}

gac.c

Cheers

Hello,
I just installed PD extended 40.3 on Windows Vista Home Premium 64 SP1. I am using an M-Audio Uno USB-MIDI interface to an external MIDI keyboard. I am experiencing a one second delay between striking a key on the keyboard and seeing the note come into PD. I have tested another program that also takes MIDI input, and there is no observable delay. I used that same version of PD extended on another computer that is running Windows XP and it seems to work fine there with the same Uno USB-MIDI interface. I did a lot of work on that computer, and have a lot of data from that computer. That computer died, but I had the data backed up and now it is on this computer. I would very much prefer not to have to start everything over with another program, so is there a way to fix the delay?
Thank you.

hi forum.

we proudly announce the first public release of our compact composer
for pd, mmm.
grab it at http://netpd.org/mmm-0.1.0.zip
mmm is best described in it's faq, see below. don't expect too much
yet, there is still a lot to be done. comments, bugreports, cash, are
welcome.

have fun with it!
christopher charles & enrique erne

faq for mmm-0.1.0 - eden

what is mmm?
mmm is a pd patch collection aimed at providing a studiolike(?),
streamlined, dynamic interface for making synthetic music.

screenshots?
http://www.netpd.org/mmm.png
ymmv depending on your operating system. we put some effort in
detecting the operating system and setting the fontsize according to
it, but quirky xorg or dpi settings might screw things up again.

where can i get it?
we currently host the mmm at http://netpd.org/mmm-0.1.0.zip ,
alternatively, you can grab netpd, enter the chat, and if either of
the authors is online, download it directly through netpd and start
rocking.

what does "mmm" stand for?
mmm was originally just the working title, but we came to like it
somehow. the original meaning is "music making machine" but you can
substitute every m for whatever you want. so "massive multiplayer
music" is okay with us, too.

what is the inspiration?
having worked on/with the bagoftricks (lots inconsistently coloured
gop-patches to be connected freely) and netpd (lots of
inconsistent-looking windows to clutter up the screen), we came to
mock up an clean, dynamic interface in which modules don't bring their
own gop or open their own window, but log onto the interface that's
provided for them by the motherpatch. all modules sharing the same
interface made it easy for them to share the same sequencer and
arranger.

what are the dependencies?
mmm should work with pd-0.39 and zexy installed. iemlib is important
for many synth and effects patches, and there's even set of gem
modules you can chain if you want.

is it actually usable?
no. this 0.1.0 release is rather a tech demo and a taste of things to
potentially come. you can crunch some acid loops out of it already,
but don't sell your protools studio equipment to start working with
mmm on monday.

how does it work?
mmm's interface (mmmmain.pd) is divided into 3 parts: there is the
module/channel view, where you can chain up synths and effects on 8
different channels. select an empty field on a channel, and then use
the scrollbox on the left to select a patch and open it. when clicking
on a patch you loaded up in the module view, the 2nd view comes into
play: from there you control the patch's sliders on the left, right of
it is the stepsequencer for each of the slider (means everything is
sequencable!). yet you won't hear anything until you did the following
2 things: press play in the uppermost row of mmmmain, and set up the
arranger to play the stepsequence. the arranger is not module-based,
but controls all modules of a channel are grouped in the arranger. for
now, you can only select pattern 01 or nothing to play in the
arranger. so set up a loop for the first pattern (loopstart:0,
looplength:1) set the first field on the channel you got your patch on
in the arranger to p01 and start making some noise.

does it work online?
yes. mmm is compatible to netpd and will automatically log on to
netpd's server if you have the netpd chat open. you can also download
the whole mmm package through netpd. feel free to jam around the
world.

what's not working yet / what is planned?
as for now, there is no support for samples whatsoever, it isn't
planned to support them soon. further, there is no hard disk recorder
available yet, but it is planned. the arranger/sequencer combo is very
crippled at the moment, only supporting 1 16-step-pattern to choose
from and 1 page of 16 patterns in the arranger. this will change
rather soon. next there are plans for luxury editing functions,
especially in the sequencer like copy, paste, random pattern,
interpolation and so on. plans exist for full keyboard control, but
this will be worked on not too soon. the module roster is far from
being complete yet, more is to come.

can i save my stuff?
should be possible with the buttons above the channels. don't rely on
the result though, this is still 0.1.0

can i add my own modules?
modules are not to hard to write, but for now, the list of selectable
modules is hardcoded. look at all the 4m-* patches in the patches
folder to see how they are ticking. contact us for adding your patch
to the mmm or try to figure out yourself how it works

what's the license?
mmm is licensed under the gnu lgpl. if you think this is a too useful
product to be free of charge, please consider donating the amount of
money you would've paid for it (or the amount of money you got from
selling your protools equipment on monday) to a trust of your choice.

who are the authors?
mmm is developed by enrique erne (eni, swiss, pd{at}mild.ch) and
christopher charles (syntax_tn, germany, chr.m.charles{at}gmail.com).
we can be contacted via email, irc (#dataflow) or directly in the
netpd chat. several patches within mmm are based upon netpd versions
of them, check netpd for the original authors. mmm shares some of it's
netcode with netpd, by roman haefeli.

disclaimer.
we cannot give you any guarantees on using mmm, not even that you
have fun. it should be relatively harmless, but don't come crying to
us if mmm accidently hijacks your *mule and downloads david hasslehoff
recordings to your computer.

eofaq