-1
How to do Android then connect with Arduino via a Bluetooth module for O Arduino receive data. I just need to understand the part of Android would be a Bluetooth Serial.
I found this code on Internet it performs connection with the module, good would like to know how it does to communicate with the grbl 0.9 that is in the Arduino, because I put in this code to send m3 but the Arduino doesn’t answer me.
Connectionthread class
package br.com.dragaosemchama.supercounter;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.os.Bundle;
import android.os.Message;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.UUID;
public class ConnectionThread extends Thread{
BluetoothSocket btSocket = null;
BluetoothServerSocket btServerSocket = null;
InputStream input = null;
OutputStream output = null;
String btDevAddress = null;
String myUUID = "00001101-0000-1000-8000-00805F9B34FB";
boolean server;
boolean running = false;
boolean isConnected = false;
/* Este construtor prepara o dispositivo para atuar como servidor.
*/
public ConnectionThread() {
this.server = true;
}
/* Este construtor prepara o dispositivo para atuar como cliente.
Tem como argumento uma string contendo o endereço MAC do dispositivo
Bluetooth para o qual deve ser solicitada uma conexão.
*/
public ConnectionThread(String btDevAddress) {
this.server = false;
this.btDevAddress = btDevAddress;
}
/* O método run() contem as instruções que serão efetivamente realizadas
em uma nova thread.
*/
public void run() {
/* Anuncia que a thread está sendo executada.
Pega uma referência para o adaptador Bluetooth padrão.
*/
this.running = true;
BluetoothAdapter btAdapter = BluetoothAdapter.getDefaultAdapter();
/* Determina que ações executar dependendo se a thread está configurada
para atuar como servidor ou cliente.
*/
if(this.server) {
/* Servidor.
*/
try {
/* Cria um socket de servidor Bluetooth.
O socket servidor será usado apenas para iniciar a conexão.
Permanece em estado de espera até que algum cliente
estabeleça uma conexão.
*/
btServerSocket = btAdapter.listenUsingRfcommWithServiceRecord("Super Counter", UUID.fromString(myUUID));
btSocket = btServerSocket.accept();
/* Se a conexão foi estabelecida corretamente, o socket
servidor pode ser liberado.
*/
if(btSocket != null) {
btServerSocket.close();
}
} catch (IOException e) {
/* Caso ocorra alguma exceção, exibe o stack trace para debug.
Envia um código para a Activity principal, informando que
a conexão falhou.
*/
e.printStackTrace();
toMainActivity("---N".getBytes());
}
} else {
/* Cliente.
*/
try {
/* Obtem uma representação do dispositivo Bluetooth com
endereço btDevAddress.
Cria um socket Bluetooth.
*/
BluetoothDevice btDevice = btAdapter.getRemoteDevice(btDevAddress);
btSocket = btDevice.createRfcommSocketToServiceRecord(UUID.fromString(myUUID));
/* Envia ao sistema um comando para cancelar qualquer processo
de descoberta em execução.
*/
btAdapter.cancelDiscovery();
/* Solicita uma conexão ao dispositivo cujo endereço é
btDevAddress.
Permanece em estado de espera até que a conexão seja
estabelecida.
*/
if (btSocket != null) {
btSocket.connect();
}
} catch (IOException e) {
/* Caso ocorra alguma exceção, exibe o stack trace para debug.
Envia um código para a Activity principal, informando que
a conexão falhou.
*/
e.printStackTrace();
toMainActivity("---N".getBytes());
}
}
/* Pronto, estamos conectados! Agora, só precisamos gerenciar a conexão.
...
*/
if(btSocket != null) {
/* Envia um código para a Activity principal informando que a
a conexão ocorreu com sucesso.
*/
this.isConnected = true;
toMainActivity("---S".getBytes());
try {
/* Obtem referências para os fluxos de entrada e saída do
socket Bluetooth.
*/
input = btSocket.getInputStream();
output = btSocket.getOutputStream();
/* Permanece em estado de espera até que uma mensagem seja
recebida.
Armazena a mensagem recebida no buffer.
Envia a mensagem recebida para a Activity principal, do
primeiro ao último byte lido.
Esta thread permanecerá em estado de escuta até que
a variável running assuma o valor false.
*/
while(running) {
/* Cria um byte array para armazenar temporariamente uma
mensagem recebida.
O inteiro bytes representará o número de bytes lidos na
última transmissão recebida.
O inteiro bytesRead representa o número total de bytes
lidos antes de uma quebra de linha. A quebra de linha
representa o fim da mensagem.
*/
byte[] buffer = new byte[1024];
int bytes;
int bytesRead = -1;
/* Lê os bytes recebidos e os armazena no buffer até que
uma quebra de linha seja identificada. Nesse ponto, assumimos
que a mensagem foi transmitida por completo.
*/
do {
bytes = input.read(buffer, bytesRead+1, 1);
bytesRead+=bytes;
} while(buffer[bytesRead] != '\n');
/* A mensagem recebida é enviada para a Activity principal.
*/
toMainActivity(Arrays.copyOfRange(buffer, 0, bytesRead-1));
}
} catch (IOException e) {
/* Caso ocorra alguma exceção, exibe o stack trace para debug.
Envia um código para a Activity principal, informando que
a conexão falhou.
*/
e.printStackTrace();
toMainActivity("---N".getBytes());
this.isConnected = false;
}
}
}
/* Utiliza um handler para enviar um byte array à Activity principal.
O byte array é encapsulado em um Bundle e posteriormente em uma Message
antes de ser enviado.
*/
private void toMainActivity(byte[] data) {
Message message = new Message();
Bundle bundle = new Bundle();
bundle.putByteArray("data", data);
message.setData(bundle);
MainActivity.handler.sendMessage(message);
}
/* Método utilizado pela Activity principal para transmitir uma mensagem ao
outro lado da conexão.
A mensagem deve ser representada por um byte array.
*/
public void write(byte[] data) {
if(output != null) {
try {
/* Transmite a mensagem.
*/
output.write(data);
} catch (IOException e) {
e.printStackTrace();
}
} else {
/* Envia à Activity principal um código de erro durante a conexão.
*/
toMainActivity("---N".getBytes());
}
}
/* Método utilizado pela Activity principal para encerrar a conexão
*/
public void cancel() {
try {
running = false;
this.isConnected = false;
btServerSocket.close();
btSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
running = false;
this.isConnected = false;
}
public boolean isConnected() {
return this.isConnected;
}
}
Main Activity
package br.com.dragaosemchama.supercounter;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.TextView;
public class MainActivity extends Activity {
/* Definição dos objetos que serão usados na Activity Principal
statusMessage mostrará mensagens de status sobre a conexão
counterMessage mostrará o valor do contador como recebido do Arduino
connect é a thread de gerenciamento da conexão Bluetooth
*/
static TextView statusMessage;
static TextView counterMessage;
ConnectionThread connect;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
/* Link entre os elementos da interface gráfica e suas
representações em Java.
*/
statusMessage = (TextView) findViewById(R.id.statusMessage);
counterMessage = (TextView) findViewById(R.id.counterMessage);
/* Teste rápido. O hardware Bluetooth do dispositivo Android
está funcionando ou está bugado de forma misteriosa?
Será que existe, pelo menos? Provavelmente existe.
*/
BluetoothAdapter btAdapter = BluetoothAdapter.getDefaultAdapter();
if (btAdapter == null) {
statusMessage.setText("Que pena! Hardware Bluetooth não está funcionando :(");
} else {
statusMessage.setText("Ótimo! Hardware Bluetooth está funcionando :)");
}
/* A chamada do seguinte método liga o Bluetooth no dispositivo Android
sem pedido de autorização do usuário. É altamente não recomendado no
Android Developers, mas, para simplificar este app, que é um demo,
faremos isso. Na prática, em um app que vai ser usado por outras
pessoas, não faça isso.
*/
btAdapter.enable();
/* Definição da thread de conexão como cliente.
Aqui, você deve incluir o endereço MAC do seu módulo Bluetooth.
O app iniciará e vai automaticamente buscar por esse endereço.
Caso não encontre, dirá que houve um erro de conexão.
*/
connect = new ConnectionThread("00:16:13:19:43:54");
connect.start();
/* Um descanso rápido, para evitar bugs esquisitos.
*/
try {
Thread.sleep(1000);
} catch (Exception E) {
E.printStackTrace();
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
public static Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
/* Esse método é invocado na Activity principal
sempre que a thread de conexão Bluetooth recebe
uma mensagem.
*/
Bundle bundle = msg.getData();
byte[] data = bundle.getByteArray("data");
String dataString= new String(data);
/* Aqui ocorre a decisão de ação, baseada na string
recebida. Caso a string corresponda à uma das
mensagens de status de conexão (iniciadas com --),
atualizamos o status da conexão conforme o código.
*/
if(dataString.equals("---N"))
statusMessage.setText("Ocorreu um erro durante a conexão D:");
else if(dataString.equals("---S"))
statusMessage.setText("Conectado :D");
else {
/* Se a mensagem não for um código de status,
então ela deve ser tratada pelo aplicativo
como uma mensagem vinda diretamente do outro
lado da conexão. Nesse caso, simplesmente
atualizamos o valor contido no TextView do
contador.
*/
counterMessage.setText(dataString);
}
}
};
/* Esse método é invocado sempre que o usuário clicar na TextView
que contem o contador. O app Android transmite a string "restart",
seguido de uma quebra de linha, que é o indicador de fim de mensagem.
*/
//Está parte que alterei para enviar m3 para testar
public void restartCounter(View view) {
connect.write("m3".getBytes());
}
}
Your question is very wide, if you have had any failed attempt, try to post the part to which you had difficulty.
– Wictor Chaves
https://developer.android.com/guide/topics/connectivity/bluetooth.html
– Leonardo Lima
@Wictorchaves I changed the question
– Vale