A spider called "Chopsticks"

i am going to start makeing the post (my internet got screwed for like all of last week so i couldn't)

but i developed some code for bluesmrif and i would like to test it but i cant find the rx and tx pins on the spider controller  

here is the code i make and could somebody test it and tell me where thoose 2 pins are as i post it

i used alot of the sample code and added some of my own

//#include <LiquidCrystal.h>

//#include <EEPROM.h>

#include <Servo.h>

#include "constants.h"

#include "IO_pins.h"

char val;         // variable to receive data from the serial port

int ledpin = 2;  // LED connected to pin 2 (on-board LED)

// define global variables

int lp=5;                  // left  pan  value (scanning)

int rp=5;                  // right pan  value (scanning)

int lt=-1;                 // left  tilt value (scanning)

int rt=+1;                 // right tilt value (scanning)

int stride=25;             // position in walking sequence 

int pos=0;                 // 0 = Sitting    28 = Standing    56 = Curled Up

int Lspeed;                // determines left  legs stride and direction (-4 to +4)

int Rspeed;                // determines right legs stride and direction (-4 to +4)

int Cspeed;                // determines crab walk  stride and direction (-4 to +4) 

int Aspeed;                // average speed used to adjust walkspeed

int OLspeed;               // Old left  speed value 

int ORspeed;               // Old right speed value 

int OCspeed;               // Old crab  speed value (straffing speed)

int lift;                  // amount to lift legs by when walking, drumming etc.

int walkspeed=25;          // number of milliseconds between walk sequence steps

int drumspeed=100;         // set the tempo of the drum sequence

unsigned long drumtime;    // timer used to control drum tempo

unsigned long walktime;    // timer used to control walking speed

unsigned long modetime;    // used to prevent the robot changing between walkmodes too quickly

// define servo center positions (Spider at rest)

int svc[84]={

  1000,1000,1000,1000,     // D26 thigh4, D27 thigh3, D28 thigh2, D29 thigh1

  1080,1100,1040,1000,     // D30 knee 4, D31 knee 3, D32 knee 2, D33 knee 1

  1650,1700,1430,1220,     // D34 hip  4, D35 hip  3, D36 hip  2, D37 hip  1

  1800,1460,1400,1250,     // D38 hip  8, D39 hip  7, D40 hip  6, D41 hip  5

  1770,1800,1870,1770,     // D42 knee 8, D43 knee 7, D44 knee 6, D45 knee 5

  2000,2000,2000,2000,     // D46 thigh8, D47 thigh7, D48 thigh6, D49 thigh5 

  0,   0,   0,   0,        // D50 Lpan  , D51 Ltilt , D52 Rpan  , D53 Rtilt

  // define servo center positions (Spider standing)

  1500,1480,1500,1520,     // D26 thigh4, D27 thigh3, D28 thigh2, D29 thigh1

  1050,1050,1050,1050,     // D30 knee 4, D31 knee 3, D32 knee 2, D33 knee 1

  1650,1700,1430,1220,     // D34 hip  4, D35 hip  3, D36 hip  2, D37 hip  1

  1800,1460,1400,1250,     // D38 hip  8, D39 hip  7, D40 hip  6, D41 hip  5

  1900,1900,1900,1750,     // D42 knee 8, D43 knee 7, D44 knee 6, D45 knee 5

  1500,1500,1500,1450,     // D46 thigh8, D47 thigh7, D48 thigh6, D49 thigh5

  0,   0,   0,   0,        // D50 Lpan  , D51 Ltilt , D52 Rpan  , D53 Rtilt

  // define servo center positions (Spider curled up)

  650, 650, 650, 650,      // D26 thigh4, D27 thigh3, D28 thigh2, D29 thigh1

  730, 730, 690, 650,      // D30 knee 4, D31 knee 3, D32 knee 2, D33 knee 1

  1650,1700,1430,1220,     // D34 hip  4, D35 hip  3, D36 hip  2, D37 hip  1

  1800,1460,1400,1250,     // D38 hip  8, D39 hip  7, D40 hip  6, D41 hip  5

  2300,2270,2330,2270,     // D42 knee 8, D43 knee 7, D44 knee 6, D45 knee 5

  2500,2450,2400,2400,     // D46 thigh8, D47 thigh7, D48 thigh6, D49 thigh5 

  2100,2000,2100,2000      // D50 Lpan  , D51 Ltilt , D52 Rpan  , D53 Rtilt

};

int svt[28];               // storage of temporary servo calculations used to control speed and direction of servos

int svp[28];               // actual servo positions

//----------------------------------------------------------- define servos ---------------------------------------------------------

Servo sv[28];                                              // Yes! servos can be an array

void setup()

{

  for(int i=0;i<24;i++)                                    // copy center positions into servo position array

  {

    svp[i]=svc[i];

    if (svp[i]==0) svp[i]=1500;     

  }

  delay(1000);

  pinMode(12,OUTPUT);                                      // pin 12 used to turn on/off servo power

  digitalWrite(12,1);                                      // power up servos - servos remain dead until they are initialized and receive a signal

  //--------------------------------------------------------- Servos initialized in a sequence to prevent the legs becoming tangled ---

  for(int i=0;i<4;i++)                                     // initialize left thighs

  {

    sv[i].attach(26+i,700,2300); 

    sv[i].writeMicroseconds(svc[i]);

    delay(50);

  }

  for(int i=20;i<24;i++)                                   // initialize right thighs

  {

    sv[i].attach(26+i,700,2300); 

    sv[i].writeMicroseconds(svc[i]);

    delay(50);

  }

  for(int i=8;i<16;i++)                                    // initialize all hips

  {

    sv[i].attach(26+i,700,2300); 

    sv[i].writeMicroseconds(svc[i]);

    delay(50);

  }

  for(int i=4;i<8;i++)                                     // initialize left knees

  {

    sv[i].attach(26+i,600,2500); 

    sv[i].writeMicroseconds(svc[i]);

    delay(50);

  }

  for(int i=16;i<20;i++)                                   // initialize right knees

  {

    sv[i].attach(26+i,600,2500); 

    sv[i].writeMicroseconds(svc[i]);

    delay(50);

  }

  Serial.begin(115200);       // start serial communication at 115200bps

  pinMode(ledpin = 13, OUTPUT);  // pin 13 (on-board LED) as OUTPUT

}

//------------------------------------------------------------------------------bluetooth following--------------------------------------------------------------------------------------------

void loop() 

{

  if( Serial.available() )       // if data is available to read

  {;}

    val = Serial.read();         // read it and store it in 'val'

  if( val == 'w' )       // is w was received, then go forward

   { 

     lspeed=4;

     rspeed=4; 

     if ((millis()-walktime)>walkspeed)

      {

       walktime=millis();

       if (Lspeed!=0 || Rspeed!=0 || Cspeed!=0) Walk1();

      }

   } 

  if( val == 's' )       // is s was received, then go backward

   { 

     lspeed=-4;

     rspeed=-4; 

     if ((millis()-walktime)>walkspeed)

      {

       walktime=millis();

       if (Lspeed!=0 || Rspeed!=0 || Cspeed!=0) Walk1();

      }

   } 

  if( val == 'd' )       // is d was received, then go right

   { 

     lspeed=4;

     rspeed=-4; 

     if ((millis()-walktime)>walkspeed)

      {

       walktime=millis();

       if (Lspeed!=0 || Rspeed!=0 || Cspeed!=0) Walk1();

      }

   } 

  if( val == 'a' )       // is a was received, then go left

   { 

     lspeed=-4;

     rspeed=4; 

     if ((millis()-walktime)>walkspeed)

      {

       walktime=millis();

       if (Lspeed!=0 || Rspeed!=0 || Cspeed!=0) Walk1();

      }

   }

  if( val == 'e' ) 

   {

     lspeed=4;

     rspeed=2;

     if ((millis()-walktime)>walkspeed)

      {

       walktime=millis();

       if (Lspeed!=0 || Rspeed!=0 || Cspeed!=0) Walk1();

      }

   }

  if( val == 'q' )

   { 

    lspeed=2;

    rspeed=4;

     if ((millis()-walktime)>walkspeed)

      {

       walktime=millis();

       if (Lspeed!=0 || Rspeed!=0 || Cspeed!=0) Walk1();

      }

   } 

  if( val == 'n')

   {

     if (pos>0) 

      {pos=0;

       walkspeed=50;

       SitStand();

      } 

   }  

  if( val == 'm') 

   {

    if (pos!=28)                                           // get back on feet if required

    {

      pos=28;

      walkspeed=25;

      lp=5;                                                // reset left eye scan to active

      rp=5;                                                // reset right eye scan to active

      SitStand();

    }

   } 

  if( val == 'b')

   {

    if(pos==28)                                            // if the robot is standing then sit down slowly

    {

      pos=0;

      walkspeed=50;

      lp=1;                                                // set left eye scan to lazy

      rp=1;                                                // set right eye scan to lazy

      SitStand();

    }

    if ((millis()-drumtime)>drumspeed)                     // control the tempo of the drumbeat

     {

      drumtime=millis();

      Drum();                                              // drumbeat sequence

     }

   }

  if( val == 'v' )

   {  

    pos=56;

    walkspeed=50;

    lp=1;                                                // set left eye scan to lazy

    rp=1;                                                // set right eye scan to lazy

    SitStand();

    HideEyes();

   } 

 }   

//=========================================================== Cycle through 4 legged walk sequence ==================================

void Walk1()

{

  lift=-500;

  stride++;                                                // cycle through gait sequence

  if (stride>23)

  {

    stride=0;                                              // restart stride sequence

    if (OLspeed>Lspeed) OLspeed--;                         // limit rate of Lspeed change to prevent leg tanglement 

    if (OLspeed<Lspeed) OLspeed++;

    if (ORspeed>Rspeed) ORspeed--;                         // limit rate of Rspeed change to prevent leg tanglement 

    if (ORspeed<Rspeed) ORspeed++;

    if (OCspeed>Cspeed) OCspeed--;                         // limit rate of Cspeed change to prevent leg tanglement 

    if (OCspeed<Cspeed) OCspeed++;

  }

  for(int i=0;i<4;i++)                                     // keep knees and hips moving

  {

    svp[i+4]-=OCspeed*4;                                   // move left  knees allowing for speed and direction

    svp[i+16]-=OCspeed*4;                                  // move right knees allowing for speed and direction

    svp[i+8]+=OLspeed*4;                                   // move left  hips allowing for speed and direction

    svp[i+12]-=ORspeed*4;                                  // move right hips allowing for speed and direction

  }

  switch(stride)

  {

  case 0:

    svp[3]=svc[3+pos]+lift;                                // lift leg1

    svp[1]=svc[1+pos]+lift;                                // lift leg3

    svp[23]=svc[23+pos]-lift;                              // lift leg5

    svp[21]=svc[21+pos]-lift;                              // lift leg7

    break;

  case 1:

    svp[11]=svc[11+pos]-(OLspeed*48);                      // move leg1 forward

    svp[9]=svc[9+pos]-(OLspeed*48);                        // move leg3 forward

    svp[15]=svc[15+pos]+(ORspeed*48);                      // move leg5 forward

    svp[13]=svc[13+pos]+(ORspeed*48);                      // move leg7 forward

    svp[7]=svc[7+pos]+(OCspeed*48);                        // extend/retract knee1

    svp[5]=svc[5+pos]+(OCspeed*48);                        // extend/retract knee3

    svp[19]=svc[19+pos]+(OCspeed*48);                      // extend/retract knee5

    svp[17]=svc[17+pos]+(OCspeed*48);                      // extend/retract knee7

    break;

  case 6:

    svp[3]=svc[3+pos];                                     // lower leg1

    svp[1]=svc[1+pos];                                     // lower leg3

    svp[23]=svc[23+pos];                                   // lower leg5

    svp[21]=svc[21+pos];                                   // lower leg7

    break;

  case 12:

    svp[2]=svc[2+pos]+lift;                                // lift leg2

    svp[0]=svc[0+pos]+lift;                                // lift leg4

    svp[22]=svc[22+pos]-lift;                              // lift leg6

    svp[20]=svc[20+pos]-lift;                              // lift leg8

    break;

  case 13:

    if (OLspeed>Lspeed) OLspeed--;                         // limit rate of Lspeed change to prevent leg tanglement 

    if (OLspeed<Lspeed) OLspeed++;

    if (ORspeed>Rspeed) ORspeed--;                         // limit rate of Rspeed change to prevent leg tanglement 

    if (ORspeed<Rspeed) ORspeed++;

    if (OCspeed>Cspeed) OCspeed--;                         // limit rate of Cspeed change to prevent leg tanglement 

    if (OCspeed<Cspeed) OCspeed++;

    svp[10]=svc[10+pos]-(OLspeed*48);                      // move leg2 forward

    svp[8]=svc[8+pos]-(OLspeed*48);                        // move leg4 forward

    svp[14]=svc[14+pos]+(ORspeed*48);                      // move leg6 forward

    svp[12]=svc[12+pos]+(ORspeed*48);                      // move leg8 forward

    svp[6]=svc[6+pos]+(OCspeed*48);                        // extend/retract knee2

    svp[4]=svc[4+pos]+(OCspeed*48);                        // extend/retract knee4

    svp[18]=svc[18+pos]+(OCspeed*48);                      // extend/retract knee6

    svp[16]=svc[16+pos]+(OCspeed*48);                      // extend/retract knee8

    break;

  case 18:

    svp[2]=svc[2+pos];                                     // lower leg2

    svp[0]=svc[0+pos];                                     // lower leg4

    svp[22]=svc[22+pos];                                   // lower leg6

    svp[20]=svc[20+pos];                                   // lower leg8

    break;

  }

  ServoUpdate();

}

void Drum()//=============================================== Drum feet on floor when bored =====================================================

{

  int lift=200;

  int thump=200;

  drumbeat++;

  if(drumbeat>31) drumbeat=0;

  switch(drumbeat)

  {

    case(0):                                              // raise knee1

    svp[7]=svc[7]+lift;

    break;

    case(1):                                              // lower knee1 hard

    svp[7]=svc[7]-thump;

    break;

    case(2):

    svp[7]=svc[7];                                        // reset knee1 

    svp[6]=svc[6]+lift;                                   // raise knee2

    break;

    case(3):

    svp[6]=svc[6]-thump;                                  // lower knee2 hard

    break;

    case(4):

    svp[6]=svc[6];                                        // reset knee2

    svp[5]=svc[5]+lift;                                   // raise knee3

    break;

    case(5):

    svp[5]=svc[5]-thump;                                  // lower knee3 hard

    break;

    case(6):

    svp[5]=svc[5];                                        // reset knee3

    break;

    case(8):

    svp[16]=svc[16]-lift;                                 // raise knee8

    break;

    case(9):

    svp[16]=svc[16]+thump;                                // lower knee8 hard

    break;

    case(10):

    svp[16]=svc[16];                                      // reset knee8

    svp[17]=svc[17]-lift;                                 // raise knee7

    break;

    case(11):

    svp[17]=svc[17]+thump;                                // lower knee7 hard

    break;

    case(12):

    svp[17]=svc[17];                                      // reset knee7

    svp[18]=svc[18]-lift;                                 // raise knee6

    break;

    case(13):

    svp[18]=svc[18]+thump;                                // lower knee6 hard

    break;

    case(14):

    svp[18]=svc[18];                                      // reset knee6

    case(16):                                             // raise knee1

    svp[7]=svc[7]+lift;

    break;

    case(17):                                             // lower knee1 hard

    svp[7]=svc[7]-thump;

    break;

    case(18):

    svp[7]=svc[7];                                        // reset knee1 

    svp[6]=svc[6]+lift;                                   // raise knee2

    break;

    case(19):

    svp[6]=svc[6]-thump;                                  // lower knee2 hard

    break;

    case(20):

    svp[6]=svc[6];                                        // reset knee2

    svp[5]=svc[5]+lift;                                   // raise knee3

    break;

    case(21):

    svp[5]=svc[5]-thump;                                  // lower knee3 hard

    break;

    case(22):

    svp[5]=svc[5];                                        // reset knee3

    break;

    case(24):

    svp[16]=svc[16]-lift;                                 // raise knee8

    svp[18]=svc[18]-lift;                                 // raise knee6

    break;

    case(25):

    svp[16]=svc[16]+thump;                                // lower knee8 hard

    svp[18]=svc[18]+thump;                                // lower knee6 hard

    break;

    case(26):

    svp[16]=svc[16];                                      // reset knee8

    svp[18]=svc[18];                                      // reset knee6

    break;

    case(28):

    svp[17]=svc[17]-lift;                                 // raise knee7

    svp[19]=svc[19]-lift;                                 // raise knee5

    break;

    case(29):

    svp[17]=svc[17]+thump;                                // lower knee7 hard

    svp[19]=svc[19]+thump;                                // lower knee5 hard

    break;

    case(30):

    svp[17]=svc[17];                                      // reset knee7

    svp[19]=svc[19];                                      // reset knee5

    break;

  }

  ServoUpdate();

}

//------------------------------------------------------sitting and standing------------------------------------------------------------------------------------------------     

void SitStand()                                               

{

  for(int i=0;i<28;i++)                                    // scan through servo positions

  {

    svt[i]=(svc[i+pos]-svp[i])/20;                         // calculate speed and direction required to move the servo to sitting/standing position in 20 steps

    if(svc[i+pos]==0) svt[i]=0;                            // a 0 indicates do not change servo position

  }

  for(int j=0;j<20;j++)                                    // move servos over a period of 20 steps to generate a smooth motion

  {

    for(int i=0;i<28;i++)

    {

      svp[i]+=svt[i];                                      // adjust the servos position

      sv[i].writeMicroseconds(svp[i]);                     // update the servos position

    }

    delay(walkspeed);                                      // controls speed of motion

  }

}

//-----------------------------------------------------------------------------------------taze---------------------------------------------------------------------------------------------

//=========================================================== Hide eyes when scared =================================================

void HideEyes()

{

  if(pos!=56)                                              // Move into curled up position

  {

    pos=56;

    SitStand();

  }

  for(int i=0;i<20;i++)

  {

    svp[11]-=23;                                           // adjust hip1

    svp[12]+=27;                                           // adjust hip8

    svp[3]+=12;                                            // adjust thigh1

    svp[20]-=11;                                           // adjust thigh8

    svp[7]+=68;                                            // adjust knee 1

    svp[16]-=67;                                           // adjust knee 8

    sv[11].writeMicroseconds(svp[11]);                     // update the servos position

    sv[12].writeMicroseconds(svp[v12]);                     // update the servos position

    sv[3].writeMicroseconds(svp[3]);                       // update the servos position

    sv[20].writeMicroseconds(svp[20]);                     // update the servos position

    sv[7].writeMicroseconds(svp[7]);                       // update the servos position

    sv[16].writeMicroseconds(svp[16]);                     // update the servos position

    delay(15);

  }

}