Show Posts
Pages: 1 2 [3] 4 5 ... 26
31  Using Arduino / Networking, Protocols, and Devices / Version 5.0 ** demo sketch ** on: June 15, 2014, 11:56:11 am
This is AndroTest V2.0 demo sketch for Joystick BT Commander V5.x

modified variables
 - STX
 - ETX
 - cmd[8]

modified functions:
 - loop()
 - getJoystickState()
 - getButtonState()

Code:
#define VERSION     "\n\nAndroTest V2.0 - @kas2014\ndemo for V5.x App"

// V2.0  changed to pure ASCII Communication Protocol ** not backward compatible **
// V1.4  improved communication errors handling
// V1.3  renamed for publishing, posted on 09/05/2014
// V1.2  Text display   ** not backward compatible **
// V1.1  Integer display
// V1.0  6 buttons + 4 data char implemented

// Demo setup:
// Button #1 controls pin #13 LED
// Button #4 toggle datafield display rate
// Button #5 configured as "push" button (momentary)
// Other buttons display demo message

// Arduino pin#2 to TX BlueTooth module
// Arduino pin#3 to RX BlueTooth module
// make sure your BT board is set @57600 bps
// better remove SoftSerial for PWM based projects

// For Mega 2560:
// remove   #include "SoftwareSerial.h", SoftwareSerial mySerial(2,3);
// search/replace  mySerial  >> Serial1
// pin#18 to RX bluetooth module, pin#19 to TX bluetooth module

#include "SoftwareSerial.h"

#define    STX          0x02
#define    ETX          0x03
#define    ledPin       13
#define    SLOW         750                            // Datafields refresh rate (ms)
#define    FAST         250                             // Datafields refresh rate (ms)

SoftwareSerial mySerial(2,3);                           // BlueTooth module: pin#2=TX pin#3=RX
byte cmd[8] = {0, 0, 0, 0, 0, 0, 0, 0};                 // bytes received
byte buttonStatus = 0;                                  // first Byte sent to Android device
long previousMillis = 0;                                // will store last time Buttons status was updated
long sendInterval = SLOW;                               // interval between Buttons status transmission (milliseconds)
String displayStatus = "xxxx";                          // message to Android device

void setup()  {
  Serial.begin(57600);
  mySerial.begin(57600);                                // 57600 = max value for softserial
  pinMode(ledPin, OUTPUT);    
  Serial.println(VERSION);
  while(mySerial.available())  mySerial.read();         // empty RX buffer
}

void loop() {
  if(mySerial.available())  {                           // data received from smartphone
    delay(2);
    cmd[0] =  mySerial.read();  
    if(cmd[0] == STX)  {
      int i=1;      
      while(mySerial.available())  {
        delay(1);
        cmd[i] = mySerial.read();
        if(cmd[i]>127 || i>7)                 break;     // Communication error
        if((cmd[i]==ETX) && (i==2 || i==7))   break;     // Button or Joystick data
        i++;
      }
      if     (i==2)          getButtonState(cmd[1]);    // 3 Bytes  ex: < STX "C" ETX >
      else if(i==7)          getJoystickState(cmd);     // 6 Bytes  ex: < STX "200" "180" ETX >
    }
  }
  sendBlueToothData();
}

void sendBlueToothData()  {
  static long previousMillis = 0;                            
  long currentMillis = millis();
  if(currentMillis - previousMillis > sendInterval) {   // send data back to smartphone
    previousMillis = currentMillis;

// Data frame transmitted back from Arduino to Android device:
// < 0X02   Buttons state   0X01   DataField#1   0x04   DataField#2   0x05   DataField#3    0x03 >  
// < 0X02      "01011"      0X01     "120.00"    0x04     "-4500"     0x05  "Motor enabled" 0x03 >    // example

    mySerial.print((char)STX);                                             // Start of Transmission
    mySerial.print(getButtonStatusString());  mySerial.print((char)0x1);   // buttons status feedback
    mySerial.print(GetdataInt1());            mySerial.print((char)0x4);   // datafield #1
    mySerial.print(GetdataFloat2());          mySerial.print((char)0x5);   // datafield #2
    mySerial.print(displayStatus);                                         // datafield #3
    mySerial.print((char)ETX);                                             // End of Transmission
  }  
}

String getButtonStatusString()  {
  String bStatus = "";
  for(int i=0; i<6; i++)  {
    if(buttonStatus & (B100000 >>i))      bStatus += "1";
    else                                  bStatus += "0";
  }
  return bStatus;
}

int GetdataInt1()  {              // Data dummy values sent to Android device for demo purpose
  static int i= -30;              // Replace with your own code
  i ++;
  if(i >0)    i = -30;
  return i;  
}

float GetdataFloat2()  {           // Data dummy values sent to Android device for demo purpose
  static float i=50;               // Replace with your own code
  i-=.5;
  if(i <-50)    i = 50;
  return i;  
}

void getJoystickState(byte data[8])    {
  int joyX = (data[1]-48)*100 + (data[2]-48)*10 + (data[3]-48);       // obtain the Int from the ASCII representation
  int joyY = (data[4]-48)*100 + (data[5]-48)*10 + (data[6]-48);
  joyX = joyX - 200;                                                  // Offset to avoid
  joyY = joyY - 200;                                                  // transmitting negative numbers

  if(joyX<-100 || joyX>100 || joyY<-100 || joyY>100)     return;      // commmunication error
  
// Your code here ...
    Serial.print("Joystick position:  ");
    Serial.print(joyX);  
    Serial.print(", ");  
    Serial.println(joyY);
}

void getButtonState(int bStatus)  {
  switch (bStatus) {
// -----------------  BUTTON #1  -----------------------
    case 'A':
      buttonStatus |= B000001;        // ON
      Serial.println("\n** Button_1: ON **");
      // your code...      
      displayStatus = "LED <ON>";
      Serial.println(displayStatus);
      digitalWrite(ledPin, HIGH);
      break;
    case 'B':
      buttonStatus &= B111110;        // OFF
      Serial.println("\n** Button_1: OFF **");
      // your code...      
      displayStatus = "LED <OFF>";
      Serial.println(displayStatus);
      digitalWrite(ledPin, LOW);
      break;

// -----------------  BUTTON #2  -----------------------
    case 'C':
      buttonStatus |= B000010;        // ON
      Serial.println("\n** Button_2: ON **");
      // your code...      
      displayStatus = "Button2 <ON>";
      Serial.println(displayStatus);
      break;
    case 'D':
      buttonStatus &= B111101;        // OFF
      Serial.println("\n** Button_2: OFF **");
      // your code...      
      displayStatus = "Button2 <OFF>";
      Serial.println(displayStatus);
      break;

// -----------------  BUTTON #3  -----------------------
    case 'E':
      buttonStatus |= B000100;        // ON
      Serial.println("\n** Button_3: ON **");
      // your code...      
      displayStatus = "Motor #1 enabled"; // Demo text message
      Serial.println(displayStatus);
      break;
    case 'F':
      buttonStatus &= B111011;      // OFF
      Serial.println("\n** Button_3: OFF **");
      // your code...      
      displayStatus = "Motor #1 stopped";
      Serial.println(displayStatus);
      break;

// -----------------  BUTTON #4  -----------------------
    case 'G':
      buttonStatus |= B001000;       // ON
      Serial.println("\n** Button_4: ON **");
      // your code...      
      displayStatus = "Datafield update <FAST>";
      Serial.println(displayStatus);
      sendInterval = FAST;
      break;
    case 'H':
      buttonStatus &= B110111;    // OFF
      Serial.println("\n** Button_4: OFF **");
      // your code...      
      displayStatus = "Datafield update <SLOW>";
      Serial.println(displayStatus);
      sendInterval = SLOW;
     break;

// -----------------  BUTTON #5  -----------------------
    case 'I':           // configured as momentary button
//      buttonStatus |= B010000;        // ON
      Serial.println("\n** Button_5: ++ pushed ++ **");
      // your code...      
      displayStatus = "Button5: <pushed>";
      break;
//   case 'J':
//     buttonStatus &= B101111;        // OFF
//     // your code...      
//     break;

// -----------------  BUTTON #6  -----------------------
    case 'K':
      buttonStatus |= B100000;        // ON
      Serial.println("\n** Button_6: ON **");
      // your code...      
       displayStatus = "Button6 <ON>"; // Demo text message
     break;
    case 'L':
      buttonStatus &= B011111;        // OFF
      Serial.println("\n** Button_6: OFF **");
      // your code...      
      displayStatus = "Button6 <OFF>";
      break;
  }
// ---------------------------------------------------------------
}


32  Using Arduino / Networking, Protocols, and Devices / Re: Android Bluetooth joystick on: June 15, 2014, 11:28:51 am
Quote
will this protocol also be used in Total RC commander ?
It will

Joystick BT Commander & Total RC commander share the same Bluetooth engine
Total RC commander has WiFi live video atop
33  Using Arduino / Networking, Protocols, and Devices / Version 5.0 ** communication protocol ** on: June 15, 2014, 10:05:40 am
New communication protocol for Joystick BT Commander V5.x

Communication from Android to Arduino                   (or to any microcontroller)

- Joystick information:
Joystick data is transmitted as ASCII data, according to this data frame:
         <STX  "Joy_X + 200"  "Joy_Y + 200"  ETX>

with STX=0x2, ETX=0x3


This is the relevant Android (Java) code snippet from Joystick Bluetooth Commander:
Code:
   final int XvalB = Xval + 200;
    final int YvalB = Yval + 200;
    if((((Xant!=Xval) || (Yant!=Yval)) || (mTimeoutCounter>=mMaxTimeoutCount && mMaxTimeoutCount>-1)))   // joystick position changed, or timeout occurred
     String toSend = String.format("%c%d%d%c", STX, XvalB, YvalB, ETX);
     sendMessage(toSend);

So, for Xval=0 Yval=0:
  XvalB = YvalB = 200
  '2' is Ascii 32 hex (decimal 50)
  '0' is Ascii 30 hex (decimal 48)
Data frame:   <0x02 0x32 0x30 0x30 0x32 0x30 0x30 0x03>

for Xval=100 Yval=100:
  XvalB = YvalB = 300
  '3' is Ascii 33 hex (decimal 51)
  '0' is Ascii 30 hex (decimal 48)
Data frame:   <0x02 0x33 0x30 0x30 0x33 0x30 0x30 0x03>

The data frame is send via BlueTooth to the arduino board and decoded.
This is the Arduino code snippet from AndroTest V2.0:
Code:
void getJoystickState(byte data[8])    {
  int joyX = (data[1]-48)*100 + (data[2]-48)*10 + (data[3]-48);       // obtain an Int from the ASCII representation
  int joyY = (data[4]-48)*100 + (data[5]-48)*10 + (data[6]-48);
  joyX = joyX - 200;                                                  // Offset to avoid
  joyY = joyY - 200;                                                  // transmitting negative numbers
 }


- Button information:
Each time an android button is pressed, the following data frame is transmitted
                <STX  buttonState  ETX>

buttonState is transmitted as a Byte value and reflects the state of the pushed button
Button #1:  ON: 'A'      OFF: 'B'
Button #2: ON: 'C'      OFF: 'D'
Button #3  ...

On the Arduino side, data frame is decoded in getButtonState()
Code:
void getButtonState(int bStatus)  {
  switch (bStatus) {
// -----------------  BUTTON #1  -----------------------
    case 'A':
      buttonStatus |= B000001;        // ON
      Serial.println("\n** Button_1: ON **");
      // your code...      
      break;
    case 'B':
      buttonStatus &= B111110;        // OFF
      Serial.println("\n** Button_1: OFF **");
      // your code...      
      break;

// -----------------  BUTTON #2  -----------------------
    case 'C':
      buttonStatus |= B000010;        // ON
      Serial.println("\n** Button_2: ON **");
      // your code...      
      break;
    case 'D':
      buttonStatus &= B111101;        // OFF
      Serial.println("\n** Button_2: OFF **");
      // your code...      
      break;

    ....
}



Communication back from Arduino to Android:
(same as V4.0)

Arduino code
Code:
void sendBlueToothData()  {

  ....

    mySerial.print((char)STX);                                             // Start of Transmission
    mySerial.print(getButtonStatusString());  mySerial.print((char)0x1);   // buttons status feedback
    mySerial.print(GetdataInt1());            mySerial.print((char)0x4);   // datafield #1
    mySerial.print(GetdataFloat2());          mySerial.print((char)0x5);   // datafield #2
    mySerial.print(displayStatus);                                         // datafield #3
    mySerial.print((char)ETX);                                             // End of Transmission
  
  ....  
}


 Data frame transmitted back from Arduino to Android device:  (by default, every 1000ms)
< STX   Buttons state   0X01   DataField#1   0x04   DataField#2   0x05   DataField#3   ETX >  

example: < 0X02    001011    0X01    120.00    0x04   -4500   0x05   Motor enabled   0x03 >

Button state:
This is a six character string reflecting the Arduino state for buttons position
button #1,#2,#4: ON, all others: OFF   >>>  001011
This feedback avoid any discrepancy with the Android device button state
An Arduino Reset will reinitialize the Android buttons, Two way communication is mandatory for "clean" control
Button state string is created in the getButtonStatusString() function.

Code:
String getButtonStatusString()  {
  String bStatus = "";
  for(i=0; i<6; i++)  {
    if(buttonStatus & B100000 >>i)      bStatus += "1";
    else                                bStatus += "0";
  }
  return bStatus;
}


Datafields:
Data is transmitted as ASCII characters using Serial.print()
Numbers are printed using an ASCII character for each digit
120.00   >>>   0X31, 0X32, 0X30, 0X2E, 0X30, 0X30

So  < 0x02     001011      0x01      120.00     0x04      -4500      0x05     Motor enabled     0x03 >
is actually transmitted as
     < 0x02,   0x30,0x30,0x31,0x30,0x31,0x31,   0X01,   0x31,0x32,0x30,0x2E,0x30,0x30,  
        0x04,  0x2D,0x34,0x35,0x30,0x30,   0x05,   0x4D,0x6F,0x74,0x6F,0x72,0x20,0x65,
        0x6E,0x61,0x62,0x6C,0x65,0x64,  0x03 >

without commas and spaces

Should you have additional questions, let me know  smiley-wink

34  Using Arduino / Networking, Protocols, and Devices / Version 5.0 coming soon on: June 14, 2014, 03:03:17 pm
Version 5.0 to be released

Early Warning

Backgroung:
Initial communication protocol was developped one year ago
At that time the App was simple (two buttons only, joystick values coded on a single Byte, no feedback communication from Arduino to Android)
Time has evolved, with added features, transmitted data amount has rapidly inflated

In some situations (RF noise environment) Arduino may receive erratic values and joystick values may be seen as button commands

Version 5.0 will feature a pure ASCII transmission protocol and definitely address this problem

This new version will be online next week
For those who want to anticipate and start modifying their code,
I will post the new communication protocol, together with the relevant demo sketch (AndroTest V2.0)
35  Using Arduino / Networking, Protocols, and Devices / Re: Android Bluetooth joystick on: June 14, 2014, 12:06:44 pm
Quote
Would it be possible for you to set it to sensorLandscape instead, that way it will automatically flip if the user turns their device upside down
Thanks joepro for this suggestion, makes a lot of sense, will definitely be included in V5.0


Quote
However the Joystick BT Commander app looks nothing like my UI design/theme, most notably you have a dark theme while my UI uses a "light" theme with a white background.
Let me have the code snippet with your theme definition
36  Using Arduino / Networking, Protocols, and Devices / Re: Android Bluetooth joystick on: June 13, 2014, 05:04:45 am
@billcat
Quote
But there is just one little problem....have a look at the screenshots  smiley-grin

Second try
Check your mail  smiley-wink
37  Using Arduino / Networking, Protocols, and Devices / Re: Android Bluetooth joystick on: June 12, 2014, 03:08:17 pm
Quote
But there is just one little problem....have a look at the screenshots  smiley-grin

Oops... Looks pretty much the same  smiley-red
Seems I edited the wrong template
Let me have another try
38  Using Arduino / Networking, Protocols, and Devices / Pan & Tilt demo on: June 12, 2014, 02:07:23 pm
@thornlv

I updated the Andro_Pan&Tilt code to make it compatible with Joystick BT commander V4.0,
should work right out of the box  smiley-wink

EDIT:   now  Android BT Commander V5.x  compatible

Code:
#define VERSION     "\n\nAndro_Pan&Tilt V3.6 - @kas2014\n** Stepper demo for V5.x App **"

// Controls two servo motors

// V3.6: Android BT Commander V5.X compatible, no button data management
// V3.0: Android BT Commander V3.X compatible, no button data management
// V2.5 can receive both Byte & Integer data
// V2.0: removed SoftwareSerial

// Android BT Commander settings:
// Options/Options for advanced users/Data Range        >>>  -100 to +100
// Options/Options for advanced users/Refresh interval  >>>  50ms

//  Arduino pin #0 to TX BlueTooth module
// BT TX to be disconnected from D0 during sketch upload

#include <Servo.h>

boolean    DEBUG =         true;

#define    pinServo_X     9
#define    pinServo_Y     10
#define    STX            0x02
#define    ETX            0x03
#define    MIN_Y          45             // vertical move limitation
#define    MAX_Y          180
#define    ZERO_Y         60             // vertical offset

byte cmd[8] = {0, 0, 0, 0, 0, 0, 0, 0};
Servo myservoX;                         // create servo objects
Servo myservoY;

void setup()  {
  Serial.begin(57600);
  myservoX.attach(pinServo_X);  
  myservoY.attach(pinServo_Y);  
  if(DEBUG)    Serial.println(VERSION);
}

void loop() {
   if(Serial.available())  {                            // data received from smartphone
    delay(2);
    cmd[0] =  Serial.read();  
    if(cmd[0] == STX)  {
      int i=1;      
      while(Serial.available())  {
        delay(1);
        cmd[i] = Serial.read();
        if(cmd[i]>127 || i>7)                 break;     // Communication error
        if((cmd[i]==ETX) && (i==2 || i==7))   break;     // Button or Joystick data
        i++;
      }
      if(i==7)     setServoPosition(cmd);
    }
  }
}

void setServoPosition(byte data[8])    {
  int joyX = (data[1]-48)*100 + (data[2]-48)*10 + (data[3]-48);       // obtain the Int from the ASCII representation
  int joyY = (data[4]-48)*100 + (data[5]-48)*10 + (data[6]-48);
  joyX = joyX - 200;                                                  // Offset to avoid
  joyY = joyY - 200;                                                  // transmitting negative numbers

  if(joyX<-100 || joyX>100 || joyY<-100 || joyY>100)     return;      // commmunication error
  
  joyX = map(joyX, -100, 100, 180, 0);   //  << adjust to change motor direction
  joyY = map(joyY, -100, 100, 0, 180);   //  <<

  joyY+=ZERO_Y;
  joyY = constrain(joyY, MIN_Y, MAX_Y);
  myservoX.write(joyX);
  myservoY.write(joyY);
  if(DEBUG)    {Serial.print(joyX); Serial.print(", "); Serial.println(joyY);}
}

Tell me if it works
39  Using Arduino / Networking, Protocols, and Devices / Re: Android Bluetooth joystick on: June 12, 2014, 12:13:55 pm
@john_lenfr
Quote
Ok, c'est bien l'appli avec le retour vidéo possible?
oops... désolé  smiley-red

The video App is not yet mainstream and will be available after Joystick BT Commander V5.0 release
Not too familiar with FPV equipment...

Video is acquired by any standalone IP camera, or any Android device with integrated camera + IP webcam App
Stream is sent via WiFi to the App through a router (for IP cameras) or directly (for Android cameras)

I use this mini router

Did you already test Joystick BT Commander V4.0 ??


40  Using Arduino / Networking, Protocols, and Devices / Re: Android Bluetooth joystick on: June 12, 2014, 08:05:53 am
Quote
Hi,
I can't find the Total RC Commander apk on GooglePlay, is that normal?

https://play.google.com/store/apps/details?id=org.projectproto.btjoystick&feature=search_result

Just checked, still there  smiley-wink


I should really change this V1.0 photo  smiley-roll
41  Using Arduino / Networking, Protocols, and Devices / Re: Android Bluetooth joystick on: June 12, 2014, 01:21:31 am
@billcat
Quote
Quote
I can easily compile a "billcat's special" with fully visible joystick
Let me know   smiley-wink
 smiley-mr-green smiley-mr-green    
Greetings Kas, well I would feel too guilty to ask,

Check your mail  smiley-cool


@all
Please post a screenshot of the App
This will help me to optimize screen layout

42  Using Arduino / Networking, Protocols, and Devices / Re: Android Bluetooth joystick on: June 12, 2014, 12:52:03 am
Hi Vic,

First, congratulation for your very professional work
I went on your flickr gallery and I am impressed  smiley-eek  smiley-eek  smiley-eek



Back to your gimball project
It should basically operate as this pan/tilt demo project

Let me have a link to your tripod


43  Using Arduino / Networking, Protocols, and Devices / Re: Android Bluetooth joystick on: June 10, 2014, 03:33:16 pm
Hi billcat   smiley

Thanks for the info
I did know that Fire OS is based on Android, but I wasn't too sure it would work

Quote
The joystick is a bit far to the right and may interfere with the menu there, I am not sure yet
I can easily compile a "billcat's special" with fully visible joystick
Let me know  smiley-wink
44  Using Arduino / Networking, Protocols, and Devices / Re: Android Bluetooth joystick on: June 04, 2014, 01:44:44 pm
Quote
I was wondering if you are able to help me. If so, I can email you the code and explain more about the problem I got.
Obviously if we get it to work, we share it here for everyone else to use

Hi jaapdemaat,
Let me have your email address via PM
45  Community / Exhibition / Gallery / Re: Android controlled RC tank with on-board Video on: June 04, 2014, 03:41:21 am
This sketch has been updated to AndroTest.ino V1.41

Code:
#define VERSION     "AndroTest V1.41A - @kas2014\ndemo for V4.X  (6 button version)"


// V1.41A Sabertooth version
// V1.3A Sabertooth version
// Demo setup: motor only, no buttons

// Arduino pin#2 to TX BlueTooth module
// Arduino pin#3 to RX BlueTooth module
// make sure your BT board is set @57600 bps
// better remove SoftSerial for PWM based projects

// For Mega 2560:
// remove   #include "SoftwareSerial.h", SoftwareSerial mySerial(2,3);
// search/replace  mySerial  >> Serial1
// pin#18 to RX bluetooth module, pin#19 to TX bluetooth module

#include "SoftwareSerial.h"

#include <Servo.h>                // Sabertooth  XXX
Servo motor_R;                    // Sabertooth  XXX
Servo motor_L;                    // Sabertooth  XXX
#define    PWM_R         5        // Sabertooth  XXX  PWM output
#define    PWM_L         6        // Sabertooth  XXX  PWM output

#define    STX          0x01
#define    ETX          0x00
#define    ledPin       13
#define    SLOW         1000                           // Datafields refresh rate (ms)
#define    FAST         250                            // Datafields refresh rate (ms)

boolean DEBUG = false;

SoftwareSerial mySerial(2,3);                           // BlueTooth module: pin#2=TX pin#3=RX
int i=0;
byte cmd[6] = {0, 0, 0, 0, 0, 0};                       // bytes received
//byte buttonStatus = 0;                                  // first Byte sent to Android device
//long previousMillis = 0;                                // will store last time Buttons status was updated
//boolean setButtonFeedback = false;                      // momentary buttons feedback to Android device
//long sendInterval = SLOW;                               // interval between Buttons status transmission (milliseconds)
//String displayStatus = "xxxx";                          // message to Android device

void setup()  {
  Serial.begin(57600);
  mySerial.begin(57600);                                // 57600 = max value for softserial
  pinMode(ledPin, OUTPUT);     
  Serial.println(VERSION);
  motor_R.attach(PWM_R);             // Sabertooth  XXX
  motor_R.attach(PWM_L);             // Sabertooth  XXX
}

void loop() {
  if(mySerial.available())  {                            // data received from smartphone
    delay(2);                                                              //  <<mod XXXXXXXX
    cmd[0] =  mySerial.read(); 
    if(cmd[0] == STX)  {
      i=1;     
      while(mySerial.available())  {
        delay(1);                                                          //  <<mod XXXXXXXX
        cmd[i] = mySerial.read();
        if(cmd[i]>127 || i>5)                               break;   // Communication error << XXX Mod
        if((cmd[i]==ETX) && ((i==2 && cmd[1]>2) || i==5))   break;   // Button or Joystick data
        i++;
      }
      if     (i==2 && cmd[1]>48 && cmd[1]<68)     getButtonState(cmd[1]);                         // 3 Bytes
      else if(i==5 && cmd[1]<3  && cmd[3]<3 )     getJoystickState(cmd);                          // 6 Bytes
      if(DEBUG)       printDebug(i);
    }
  }
  sendBlueToothData();                                                       //  <<mod XXXXXXXX
}


void getJoystickState(byte data[5])    {
  int joyX = (data[1]<<7) + data[2];
  int joyY = (data[3]<<7) + data[4];
  joyX = joyX - 200;               // Offset to avoid
  joyY = joyY - 200;               // transmitting negative numbers

  if(!DEBUG)  {
    Serial.print("Joystick position:  ");
    Serial.print(joyX); 
    Serial.print(", "); 
    Serial.println(joyY);
  }
 
// Your code here ...

  joyX = map(joyX, -100, 100, 0, 180);             // Sabertooth  XXX
  joyY = map(joyY, -100, 100, 0, 180);             // Sabertooth  XXX
 
// 180: full forward,  0: full reverse, 90: stop
  motor_R.write(joyX);                             // Sabertooth  XXX
  motor_L.write(joyY);                             // Sabertooth  XXX
}

void getButtonState(int bStatus)  {
  // do nothing
}

void sendBlueToothData()  {
  // do nothing
}

//String getButtonStatusString()  {
//}

//int GetdataInt1()  {              // Data dummy values sent to Android device for demo purpose
//}

//float GetdataFloat2()  {           // Data dummy values sent to Android device for demo purpose
//}

void printDebug(int nByte)  {
  if(nByte ==2)    {   
//    Serial.print("buttonStatus: "); Serial.print(buttonStatus);
//    Serial.print("  bin: "); Serial.println(getButtonStatusString());   
//    Serial.print("Button: < ");
  }
  else if(nByte ==5)  Serial.print("Joystick: < ");
  else                Serial.print("*error*: < ");
  for(int j =0; j<nByte+1; j++) { Serial.print(cmd[j]); Serial.print(" "); }
  Serial.println(">");
}


Quote
When the joystick goes left the bot goes forward, when the joystick goes right the bot goes backward.
The forward and backward movement of the stick does nothing to the bot.
smiley-roll smiley-roll smiley-roll
Left motor should turn Forward/Backward with joystick moving North/South
Right motor should turn Forward/Backward with joystick moving East/West
Double check your cabling and let me know the status
Pages: 1 2 [3] 4 5 ... 26