# BtEchoServer.py

from btpycom import *

def onStateChanged(state, msg):
    if state == "LISTENING":
        print "Server is listening"
    elif state == "CONNECTED":
        print "Connection established to", msg
    elif state == "MESSAGE":
        print "Got message", msg
        server.sendMessage(msg)
       
serviceName = "EchoServer"
server = BTServer(serviceName, stateChanged = onStateChanged)

# BtEchoClient.py

from btcom import *  # TigerJython
from btpycom import *  # Standard-Python (PC, Raspi, ...)

def onStateChanged(state, msg):
    global reply
    if state == "CONNECTING":
        print "Connecting", msg
    elif state == "CONNECTION_FAILED":
        print "Connection failed", msg
    elif state == "CONNECTED":
        print "Connected", msg
    elif state == "DISCONNECTED":
        print "Disconnected", msg
    elif state == "MESSAGE":
        print "Message", msg
        reply = msg
       
serviceName = "EchoServer"
print "Performing search for service name", serviceName
client = BTClient(stateChanged = onStateChanged)
serverInfo = client.findService(serviceName, 20)
if serverInfo == None:
    print "Service search failed"
else:
    print "Got server info", serverInfo
    if client.connect(serverInfo, 20):
        for n in range(0, 101):
            client.sendMessage(str(n))
            reply = ""
            while reply == "":
                time.sleep(0.001)
        client.disconnect()  

# BTRover.py

import RPi.GPIO as GPIO
from btpycom import *

def onStateChanged(state, msg):
    if state == "LISTENING":
        print "Waiting for connecting controller..."
        stop()
    elif state == "CONNECTED":
        print "Connection to", msg, "established"
    elif state == "MESSAGE":
        print "Got command:", msg    
        if msg == "FORWARD":
            forward()
        elif msg == "BACKWARD":    
            backward()
        elif msg == "STOP":    
            stop()
        elif msg == "LEFT":    
            left()
        elif msg == "RIGHT":    
            right()

# adapt to your rover
P_MOTA1 = 40 # right motor
P_MOTA2 = 38 # right motor
P_MOTB1 = 36 # left motor
P_MOTB2 = 32 # left motor

def forward():
    GPIO.output(P_MOTA1, GPIO.HIGH)
    GPIO.output(P_MOTA2, GPIO.LOW)
    GPIO.output(P_MOTB1, GPIO.HIGH)
    GPIO.output(P_MOTB2, GPIO.LOW)

def backward():        
    GPIO.output(P_MOTA1, GPIO.LOW)
    GPIO.output(P_MOTA2, GPIO.HIGH)
    GPIO.output(P_MOTB1, GPIO.LOW)
    GPIO.output(P_MOTB2, GPIO.HIGH)

def left():
    GPIO.output(P_MOTA1, GPIO.HIGH)
    GPIO.output(P_MOTA2, GPIO.LOW)
    GPIO.output(P_MOTB1, GPIO.LOW)
    GPIO.output(P_MOTB2, GPIO.HIGH)

def right():
    GPIO.output(P_MOTA1, GPIO.LOW)
    GPIO.output(P_MOTA2, GPIO.HIGH)
    GPIO.output(P_MOTB1, GPIO.HIGH)
    GPIO.output(P_MOTB2, GPIO.LOW)
    
def stop():
    GPIO.output(P_MOTA1, GPIO.LOW)
    GPIO.output(P_MOTA2, GPIO.LOW)
    GPIO.output(P_MOTB1, GPIO.LOW)
    GPIO.output(P_MOTB2, GPIO.LOW)

def setup():
    GPIO.setmode(GPIO.BOARD)
    GPIO.setwarnings(False)
    GPIO.setup(P_MOTA1, GPIO.OUT)
    GPIO.setup(P_MOTA2, GPIO.OUT)
    GPIO.setup(P_MOTB1, GPIO.OUT)
    GPIO.setup(P_MOTB2, GPIO.OUT)
    
setup()
serviceName = "BTRover"
BTServer(serviceName, stateChanged = onStateChanged)

# RoverControl.py
# TigerJython

from entrydialog import *
from btcom import *

def showDialog():
    global dlg, buttons
    buttons = [ButtonEntry("Left"), ButtonEntry("Forward"), ButtonEntry("Stop"),
               ButtonEntry("Backward"), ButtonEntry("Right")]
    pane = EntryPane(buttons[0], buttons[1], buttons[2], buttons[3], buttons[4])
    dlg = EntryDialog(pane)
    dlg.setTitle("Remote Control")
    dlg.show()

showDialog()
commands = ["LEFT", "FORWARD", "STOP", "BACKWARD", "RIGHT"]

def onStateChanged(state, msg):
    pass
       
serviceName = "BTRover"
client = BTClient(stateChanged = onStateChanged)
dlg.setTitle("Searching for rover. Please wait...")
serverInfo = client.findService(serviceName, 30)
if serverInfo == None:
    dlg.setTitle("Rover not found")
else:
    if client.connect(serverInfo, 20):
        dlg.setTitle("Connected to " + serverInfo[0])
        while not dlg.isDisposed():
            for n in range(len(buttons)):
                if buttons[n].isTouched():
                    client.sendMessage(commands[n])
        client.disconnect()  

# BTRover1.py

import RPi.GPIO as GPIO
from btpycom import *

def onStateChanged(state, msg):
    global speed
    if state == "LISTENING":
        print "Waiting for connecting controller..."
        stop()
    elif state == "CONNECTED":
        print "Connection to", msg, "established"
    elif state == "MESSAGE":
        print "Got command:", msg    
        if msg == "FASTER":
            if speed < 100:
                speed += 10
            if speed > 0:
                forward(speed)
            else:
                backward(-speed)
        elif msg == "SLOWER":    
            if speed > -100:
               speed -= 10
            if speed > 0:
                forward(speed)
            else:
                backward(-speed)
        elif msg == "STOP":
            speed = 0    
            stop()
        elif msg == "LEFT":
            left(30)
        elif msg == "RIGHT":
            right(30)

P_MOTA1 = 40
P_MOTA2 = 38
P_MOTB1 = 36
P_MOTB2 = 32
fPWM = 60  # Hz

def setup():
    global pwm_a1, pwm_a2, pwm_b1, pwm_b2
    GPIO.setmode(GPIO.BOARD)
    GPIO.setwarnings(False)
    GPIO.setup(P_MOTA1, GPIO.OUT)
    pwm_a1 = GPIO.PWM(P_MOTA1, fPWM)
    pwm_a1.start(0)
    GPIO.setup(P_MOTA2, GPIO.OUT)
    pwm_a2 = GPIO.PWM(P_MOTA2, fPWM)
    pwm_a2.start(0)
    GPIO.setup(P_MOTB1, GPIO.OUT)
    pwm_b1 = GPIO.PWM(P_MOTB1, fPWM)
    pwm_b1.start(0)
    GPIO.setup(P_MOTB2, GPIO.OUT)
    pwm_b2 = GPIO.PWM(P_MOTB2, fPWM)
    pwm_b2.start(0)

def stop():
    forward(0)
       
def forward(speed):
    pwm_a1.ChangeDutyCycle(speed)
    pwm_a2.ChangeDutyCycle(0)
    pwm_b1.ChangeDutyCycle(speed)
    pwm_b2.ChangeDutyCycle(0)

def left(speed):
    pwm_a1.ChangeDutyCycle(speed)
    pwm_a2.ChangeDutyCycle(0)
    pwm_b1.ChangeDutyCycle(0)
    pwm_b2.ChangeDutyCycle(speed)

def right(speed):
    pwm_a1.ChangeDutyCycle(0)
    pwm_a2.ChangeDutyCycle(speed)
    pwm_b1.ChangeDutyCycle(speed)
    pwm_b2.ChangeDutyCycle(0)
    
def backward(speed):
    pwm_a2.ChangeDutyCycle(speed)
    pwm_a1.ChangeDutyCycle(0)
    pwm_b2.ChangeDutyCycle(speed)
    pwm_b1.ChangeDutyCycle(0)
 
speed = 0    
setup()
serviceName = "BTRover"
BTServer(serviceName, stateChanged = onStateChanged)

// RoverControlApp.java

package rovercontrol.app;

import ch.aplu.android.*;
import android.graphics.Color;
import android.bluetooth.*;
import ch.aplu.android.bluetooth.*;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;


public class RoverControlApp extends GameGrid
  implements GGPushButtonListener
{
  private GGPushButton faster;
  private GGPushButton slower;
  private GGPushButton left;
  private GGPushButton right;
  private GGPushButton stop;
  private GGTextField tf;
  private BluetoothClient bc;
  private DataInputStream dis;
  private DataOutputStream dos;

  public RoverControlApp()
  {
    super(21, 21, 0);
    setScreenOrientation(PORTRAIT);
  }

  public void main()
  {
    String serverName = askName();
    getBg().clear(Color.BLUE);
    new GGTextField("Rover Control App",
      new Location(0, 1), true).show();
    addButtons();
    tf = new GGTextField("Trying to connect...", new Location(4, 19), true);
    tf.show();
      
    // Search device   
    BluetoothDevice serverDevice = searchDevice(serverName);
    if (serverDevice != null)
    {
      bc = new BluetoothClient(serverDevice);
      boolean rc = bc.connect();
      if (!rc)
      {
         tf.hide();
         tf = new GGTextField("Connection failed", new Location(4, 19), true);
         tf.show();
         return;
      }
      tf.hide();
      tf = new GGTextField("Connection established", new Location(3, 19), true);
      tf.show();
      dis = new DataInputStream(bc.getInputStream());
      dos = new DataOutputStream(bc.getOutputStream());
      enableButtons();
  }  
  }
  
  private String askName()
  {
    GGPreferences prefs = new GGPreferences(this);
    String oldName = prefs.retrieveString("BluetoothName");
    String newName = null;
    while (newName == null || newName.equals(""))
    {
      newName = GGInputDialog.show(this, "Rover Control App", 
        "Enter Bluetooth Name",
        oldName == null ? "raspberrypi" : oldName);
    }
    prefs.storeString("BluetoothName", newName);
    return newName;
 }  

  private void addButtons()
  {
    faster = new GGPushButton("faster");
    faster.setRepeatPeriod(100);
    addActor(faster, new Location(10, 5));
    slower = new GGPushButton("slower");
    slower.setRepeatPeriod(100);
    addActor(slower, new Location(10, 15));
    left = new GGPushButton("left");
    addActor(left, new Location(3, 10));
    right = new GGPushButton("right");
    addActor(right, new Location(17, 10));
    stop = new GGPushButton("stop");
    addActor(stop, new Location(10, 10));
  }

  private void enableButtons()
  {
    faster.addPushButtonListener(this);
    slower.addPushButtonListener(this);
    left.addPushButtonListener(this);
    right.addPushButtonListener(this);
    stop.addPushButtonListener(this);
  }

  public void onPause()
  {
    super.onPause();
  }

  public void buttonPressed(GGPushButton button)
  {
    if (button == faster)
      faster();
    if (button == slower)
      slower();
    if (button == left)
      turnLeft();
    if (button == right)
      turnRight();
    if (button == stop)
      doStop();
  }

  public void buttonReleased(GGPushButton button)
  {
  }

  public void buttonClicked(GGPushButton button)
  {
  }

  public void buttonRepeated(GGPushButton button)
  {
    if (button == faster)
      faster();
    if (button == slower)
      slower();
  }

  private void faster()
  {
     sendMessage("FASTER");
  }

  private void slower()
  {
     sendMessage("SLOWER");
  }


  private void doStop()
  {
     sendMessage("STOP");
  }

  private void turnLeft()
  {
     sendMessage("LEFT");
  }

  private void turnRight()
  {
     sendMessage("RIGHT");
  }
  
  private void sendMessage(String msg)
  {
    try
    {
     dos.writeBytes(msg + "\0");
     dos.flush();
    }
    catch (IOException ex)
    {
      tf.hide();
      tf = new GGTextField("Connection lost", new Location(3, 19), true);
      tf.show();
    }
  }

 // Searches for device in set of paired devices. 
 //Returns null, if search fails.
  private BluetoothDevice searchDevice(String btName)
  {
    BluetoothAdapter adapter =
      BluetoothDiscovery.getBluetoothAdapter(this);
    if (adapter == null)
      return null;

    if (!adapter.isEnabled())
    {
      requestBluetoothEnable();
      if (!adapter.isEnabled())
        return null;
    }
    BluetoothDiscovery bd = new BluetoothDiscovery(this);
    BluetoothDevice device = bd.getPairedDevice(btName);
    return device;
  }
 
}