(Solved) Snag using Brett's PID front end

I feel that I am missing something very basic here but I can't see what it is. I have loaded the PID library and loaded Brett's sample sketch PID_FrontEnd_ArduinoSampleCode.ino onto the Uno i'm using. I have installed Processing 2.1.1 (on OSX 10.8.5) and loaded the PID FrontEnd v03 sketch and run that from the Processing environment. I get the appropriate window and the port to which the Arduino is connected shows up in the list of available ports in the terminal window in Processing. However, If I try to change something from the front end (say Kp or toggle from manual to automatic) and hit Send_to_Arduino I see no serial lights blink on the Arduino and the status window on the front end does not update. Do I need to explicitly specify the serial port to be used in one or the other of these sketches? or am I missing something even more basic than that? Thanks in advance for any insight.

or am I missing something even more basic than that?

Yes, you are. Code, for one thing. You seem to be under the impression that we know what code you are referring to. Wrong.

You seem to be under the impression that we know what COM port your Arduino is connected to. Wrong.

You seem to be under the impression that we know what list of COM ports are displayed. Wrong.

You seem to be under the impression that we can see which item in the COM port list is actually being selected. Wrong.

Ok, Here is what I am working with:
Note: I was unable to post both sketches in one response so I’ll put the Processing sketch in a following reply.

The serial port that the Arduino is using is /dev/tty.usbmodemfa131

The ports listed in the terminal window of the Processing environment when the PID front end sketch is run are:
/dev/cu.Bluetooth-Modem /dev/cu.Bluetooth-PDA-Sync /dev/cu.Bluetooth-Serial-1 /dev/cu.Bluetooth-Serial-2 /dev/cu.usbmodemfa131 /dev/tty.Bluetooth-Modem /dev/tty.Bluetooth-PDA-Sync /dev/tty.Bluetooth-Serial-1 /dev/tty.Bluetooth-Serial-2 /dev/tty.usbmodemfa131

I do not know how to determine which serial port the Processing sketch is actually selecting so I cannot answer that portion of your response

Here is the Arduino example sketch supplied with the PIDFrontEnd_v03 download

/******************************************************************
 * PID Simple Example (Augmented with Processing.org Communication)
 * Version 0.3
 * by Brett Beauregard
 * License: Creative-Commons Attribution Share-Alike
 * April 2011
 ******************************************************************/

#include <PID_v1.h>

//Define Variables we'll be connecting to
double Setpoint, Input, Output;
int inputPin=0, outputPin=3;

//Specify the links and initial tuning parameters
PID myPID(&Input, &Output, &Setpoint,2,5,1, DIRECT);


unsigned long serialTime; //this will help us know when to talk with processing

void setup()
{
  //initialize the serial link with processing
  Serial.begin(9600);
  
  //initialize the variables we're linked to
  Input = analogRead(inputPin);
  Setpoint = 100;

  //turn the PID on
  myPID.SetMode(AUTOMATIC);
}

void loop()
{
  //pid-related code
  Input = analogRead(inputPin);
  myPID.Compute();
  analogWrite(outputPin,Output);
  

  
  //send-receive with processing if it's time
  if(millis()>serialTime)
  {
    SerialReceive();
    SerialSend();
    serialTime+=500;
  }
  
  
}


/********************************************
 * Serial Communication functions / helpers
 ********************************************/


union {                // This Data structure lets
  byte asBytes[24];    // us take the byte array
  float asFloat[6];    // sent from processing and
}                      // easily convert it to a
foo;                   // float array



// getting float values from processing into the arduino
// was no small task.  the way this program does it is
// as follows:
//  * a float takes up 4 bytes.  in processing, convert
//    the array of floats we want to send, into an array
//    of bytes.
//  * send the bytes to the arduino
//  * use a data structure known as a union to convert
//    the array of bytes back into an array of floats

//  the bytes coming from the arduino follow the following
//  format:
//  0: 0=Manual, 1=Auto, else = ? error ?
//  1: 0=Direct, 1=Reverse, else = ? error ?
//  2-5: float setpoint
//  6-9: float input
//  10-13: float output  
//  14-17: float P_Param
//  18-21: float I_Param
//  22-245: float D_Param
void SerialReceive()
{

  // read the bytes sent from Processing
  int index=0;
  byte Auto_Man = -1;
  byte Direct_Reverse = -1;
  while(Serial.available()&&index<26)
  {
    if(index==0) Auto_Man = Serial.read();
    else if(index==1) Direct_Reverse = Serial.read();
    else foo.asBytes[index-2] = Serial.read();
    index++;
  } 
  
  // if the information we got was in the correct format, 
  // read it into the system
  if(index==26  && (Auto_Man==0 || Auto_Man==1)&& (Direct_Reverse==0 || Direct_Reverse==1))
  {
    Setpoint=double(foo.asFloat[0]);
    //Input=double(foo.asFloat[1]);       // * the user has the ability to send the 
                                          //   value of "Input"  in most cases (as 
                                          //   in this one) this is not needed.
    if(Auto_Man==0)                       // * only change the output if we are in 
    {                                     //   manual mode.  otherwise we'll get an
      Output=double(foo.asFloat[2]);      //   output blip, then the controller will 
    }                                     //   overwrite.
    
    double p, i, d;                       // * read in and set the controller tunings
    p = double(foo.asFloat[3]);           //
    i = double(foo.asFloat[4]);           //
    d = double(foo.asFloat[5]);           //
    myPID.SetTunings(p, i, d);            //
    
    if(Auto_Man==0) myPID.SetMode(MANUAL);// * set the controller mode
    else myPID.SetMode(AUTOMATIC);             //
    
    if(Direct_Reverse==0) myPID.SetControllerDirection(DIRECT);// * set the controller Direction
    else myPID.SetControllerDirection(REVERSE);          //
  }
  Serial.flush();                         // * clear any random data from the serial buffer
}

// unlike our tiny microprocessor, the processing ap
// has no problem converting strings into floats, so
// we can just send strings.  much easier than getting
// floats from processing to here no?
void SerialSend()
{
  Serial.print("PID ");
  Serial.print(Setpoint);   
  Serial.print(" ");
  Serial.print(Input);   
  Serial.print(" ");
  Serial.print(Output);   
  Serial.print(" ");
  Serial.print(myPID.GetKp());   
  Serial.print(" ");
  Serial.print(myPID.GetKi());   
  Serial.print(" ");
  Serial.print(myPID.GetKd());   
  Serial.print(" ");
  if(myPID.GetMode()==AUTOMATIC) Serial.print("Automatic");
  else Serial.print("Manual");  
  Serial.print(" ");
  if(myPID.GetDirection()==DIRECT) Serial.println("Direct");
  else Serial.println("Reverse");
}

The ports listed

are in the form of a list, not crap smeared across the page.

I do not know how to determine which serial port the Processing sketch is actually selecting so I cannot answer that portion of your response

You'll need to go the Processing site, and examine each statement in the code, to find the one that actually connects to the Serial port (oops, there's a clue; damned) and understand how it selects an item from the list.

Found the problem and thought someone else may hit the same issue first time out.
Run the processing sketch and find the serial port your Arduino is on in the list of serial ports. Make a note of which position in the list is occupied by your serial port (Counting from 0 not 1 so if your port is 3rd in the list it’s position is 2) . Find the line:
myPort = new Serial(this, Serial.list()[1], 9600); in the Processing sketch and replace the number in Serial.list()[1] with the position of your serial port in my case myPort = new Serial(this, Serial.list()[9], 9600);. Restart the sketch and poof, the front end works like a charm. Hope this help someone.