domenica 7 dicembre 2014

Controllo Arduino via Bluetooth

In questo post descrivo come ho collegato Arduino Uno (per altri tipi di Arduino i collegamenti sono simili) con un modulo JY-MCU Bluetooth che avevo comprato qualche tempo fa.









Questo modulo mi permette di collegarmi in Bluetooth attraverso il mio telefono o tablet o PC.
Il modulo viene visto da Arduino come una comunicazione seriale e quindi e' di facilissima gestione.

Ho gia' im mente un piccolo progettino per la mia casa con questo modulo, ma per il momento concentriamoci su come utilizzare il modulo.

Per utilizzare il modulo con Arduino ci sono sue passaggi da eseguire:


  1. Configurare il modulo
  2. Utilizzare il modulo







Configurazione del modulo JY-MCU

Questo articolo speiga molto bene come configurare il modulo JYMCU https://github.com/rwaldron/johnny-five/wiki/JY-MCU-Bluetooth-Serial-Port-Module-Notes

Effettuate i collegamenti del modulo bluettoth come in figura



Nel mio caso ho usato 4 fili di colo Nero, Marrone, Rosso ed Arancione.

I fili sono collegati in questo modo al modulo bluettoth:


  • nero -> VCC
  • marrone -> GND
  • rosso -> TX
  • arancio -> RX




Adesso ho collegato l'altra estremita' dei fili a Arduino in questo modo







  • nero -> pin +5V
  • marrone -> pin GND
  • rosso -> pin 10
  • arancio -> pin 11




E' importante collegare i fili in modo corretto siccome il software di configurazione del modulo assegna al pin 10 il ruolo RX e al pin 11 il ruolo di TX.

Quindi come si capisce dalle conenssione il collegamento e' ovviamente incrociato in modo che:

  • modulo TX --> Arduino RX (pin 10)
  • modulo RX -> Arduino TX (pin 11)






Una volta che il modulo bluetooth e' stato collegato ad Arduino come descritto sopra caricare il seguente sctach su Arduino:

 

#define ROBOT_NAME "YOUR ARDUINO NAME"

// If you haven't configured your device before use this
#define BLUETOOTH_SPEED 9600
// If you are modifying your existing configuration, use this:
// #define BLUETOOTH_SPEED 57600

#include 

// Swap RX/TX connections on bluetooth chip
//   Pin 10 --> Bluetooth TX
//   Pin 11 --> Bluetooth RX
SoftwareSerial mySerial(10, 11); // RX, TX


/*
  The posible baudrates are:
    AT+BAUD1-------1200
    AT+BAUD2-------2400
    AT+BAUD3-------4800
    AT+BAUD4-------9600 - Default for hc-06
    AT+BAUD5------19200
    AT+BAUD6------38400
    AT+BAUD7------57600 - Johnny-five speed
    AT+BAUD8-----115200
    AT+BAUD9-----230400
    AT+BAUDA-----460800
    AT+BAUDB-----921600
    AT+BAUDC----1382400
*/


void setup()
{
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
  Serial.println("Starting config");
  mySerial.begin(BLUETOOTH_SPEED);
  delay(1000);

  // Should respond with OK
  mySerial.print("AT");
  waitForResponse();

  // Should respond with its version
  mySerial.print("AT+VERSION");
  waitForResponse();

  // Set pin to 0000
  mySerial.print("AT+PIN0000");
  waitForResponse();

  // Set the name to ROBOT_NAME
  mySerial.print("AT+NAME");
  mySerial.print(ROBOT_NAME);
  waitForResponse();

  // Set baudrate to 57600
  mySerial.print("AT+BAUD7");
  waitForResponse();

  Serial.println("Done!");
}

void waitForResponse() {
    delay(1000);
    while (mySerial.available()) {
      Serial.write(mySerial.read());
    }
    Serial.write("\n");
}

void loop() {}




Se tutto ha funzionato correttamente dovreste vedere un output come questo:






A questo punto il modulo bluetooth e' correttamente configurato e pronto per essere utilizzato.

Il modulo bluetooth adersso puo' essere scollegato da Arduino in quanto per il suo utilizzo dobbiamo collegarlo in modo leggermente diverso.

Utilizzo del modulo JY-MCU

Per verificare il funzionamento del modulo ho creato un simplicissimo esempio.
Voglio poter accendere o spegnere due led dal mio cellulare inviando dei semplici comando a Arduino.

I comandi hanno il seguente formato

# PIN--COMANDO

dove 

  • PIN: numero di pin su arduino
  • COMANDO: ON o OFF

Quindi per esemprio il comando: 10-ON imposta il pin 10 di Arduino a HIGH
Mentre 10-OFF impostal il pin 10 di Arduino a LOW






Circuito di prova

Ho create il semplicissimo circuito rappresentato qui sotto su una breadboard.

Ho collegato il pin 8 e 10 rispettivamente a due led inserendo una resistena per limitare la corrente. Questo e' importantissimo altrimenti quasi certamente si brucia il pin di Arduino o si puo' addirittura danneggiare tutta la scheda Arduino (io ho usato resistenze da 220 Ohm in quanto ho solo queste)












Come si vede il modulo JY-MCU bluetooth e' collegato ad Arduino in modo diverso da prima. Piu' precisamente:

  • nero -> pin +5V
  • marrone -> pin GND
  • rosso -> pin 0 (RX)
  • arancio -> pin 1 (TX)





In questo modo il modulo bluetooth viene visto da Arduino come una comunicazione seriale.


Sketch di esempio

Ho creato un semplicissimo sketch che rimane in attesa ed esegue un comando ricevuto tramite bluetoot

Ovviamente lo sketch e' solo per verificare il funzionamento e' non e' solido abbastanza per un utilizzo piu' serio, ma dovrebbe essere d'aiuto a capire meglio come usare il modulo stesso.


 
#include 

//struttura del comando
struct CMD {
  int  pin;  //pin da controllare
  char *cmd; //comando da applicare al pin (ON|OFF)
};

int i = 0;
int readByte = 0;
char buff[255]; //contiene i dati ricevuti
struct CMD parsed_cmd; //comando ricevuto

void setup()
{
  Serial.begin(57600); 
  bt_println("Init!!!!");
}

//pulisce il buffer dopo che e' stato utilizzato
void clear_buff()
{
  for (i=0; i < 255; i++)
    buff[i] = 0;
}

//println verso bluetooth
void bt_println(String str)
{
  Serial.println(str);
  delay(10);
}

//print verso bluetooth
void bt_print(String str)
{
  Serial.print(str);
  delay(10);
}

//parsing della stringa ricevuta in un comando da eseguire
//comando ha il seguente formato:  PIN--COMANDO. esempio: 13--OFF; 13--ON
struct CMD read_command(char *command)
{
  struct CMD cmd;
  const char s[3] = "--";
  char *token;
 
  token = strtok(command, s);
  cmd.pin = atoi(token);
  
  token = strtok(NULL, s);
  cmd.cmd = token;  

  return cmd;
}

int validate_cmd(struct CMD cmd)
{
  return ((cmd.pin > 0) && ((String(cmd.cmd) == "ON") || (String(cmd.cmd) == "OFF")));
}

void execute_cmd(struct CMD cmd)
{
  int pin = cmd.pin;
  int status = (String(cmd.cmd) == "ON")?HIGH:LOW; 
 
  bt_println(String("Settin PIN: ") + String(pin) + String(" to ") + String(status));
  
  pinMode(pin, OUTPUT);
  digitalWrite(pin, status); 
}

void loop()
{
  clear_buff();  
  delay(1000);
  
  if ((readByte = Serial.available()) > 0) {
    bt_println("-------------------------");
    
    Serial.readBytes(buff, readByte);
    
    bt_println(String("Parsing commnand: ") + buff);
        
    parsed_cmd = read_command(buff);
    
    if (validate_cmd(parsed_cmd)) {   
      bt_println(String("Serial PIN = ") + String(parsed_cmd.pin));
      bt_println(String("Serial STATUS = ") + parsed_cmd.cmd);
      execute_cmd(parsed_cmd);
    }
    else
      bt_println("ERROR: COMMAND NOT VALID!");
  }
}


Verifica del funzionamento

Adesso che abbiamo completato la configurazione del modulo bluetooth, il cablaggio del semplice circuito di prova non ci resta che caricare lo sketch su Arduino.

Per verificare che il tutto funzioni in modo corretto ho installato una semplice app sul mio cellulare Android (per iOS esistono app simili).

L'app che ho installato si chiama BluetoothTerminal.
Questa app mi permette di digitare dei caratteri (comandi) e di inviarli tramite bluetooth al mio Arduino

Nel video si vede che i led si accendono e si spengono quando invio il comando corretto ad Arduino.

Il modulo che ho usato io ha un pin uguale a 0000 per l'accoppiamento del bluetooth con il cellulare.





Come sempre se avete idee per migliorare questo progetto saro' lieto di leggere i vostri commenti e  di aggiornare il post.