Arduino Android App: Parte V

Ya vimos como conectarnos a dispositivos BT.  Ahora veamos como comunicarnos con esos dispositivos!

Requisitos:

1. Computadora (mac)
2. Arduino UNO
3. Arduino IDE
4. HM10/11
5. LED & Resistor 220O
6. Android Studio (http://developer.android.com/sdk/installing/index.html?pkg=studio)

Ahora vamos a crear una aplicación para Android y un sketch para Arduino y hacer que se comuniquen de forma sencilla para controlar una LED.

Iniciemos con la Arduino Sketch para ArduDroid de Hakim Bitar:

[code]
/*
PROJECT: ArduDroid
PROGRAMMER: Hazim Bitar (techbitar at gmail dot com)
DATE: Oct 31, 2013
FILE: ardudroid.ino
LICENSE: Public domain
*/

#define START_CMD_CHAR ‘*’
#define END_CMD_CHAR ‘#’
#define DIV_CMD_CHAR ‘|’
#define CMD_DIGITALWRITE 10
#define CMD_ANALOGWRITE 11
#define CMD_TEXT 12
#define CMD_READ_ARDUDROID 13
#define MAX_COMMAND 20 // max command number code. used for error checking.
#define MIN_COMMAND 10 // minimum command number code. used for error checking.
#define IN_STRING_LENGHT 40
#define MAX_ANALOGWRITE 255
#define PIN_HIGH 3
#define PIN_LOW 2

String inText;

void setup() {
Serial.begin(9600);
Serial.println(“ArduDroid 0.12 Alpha by TechBitar (2013)”);
Serial.flush();
}

void loop()
{
Serial.flush();
int ard_command = 0;
int pin_num = 0;
int pin_value = 0;

char get_char = ‘ ‘; //read serial

// wait for incoming data
if (Serial.available() < 1) return; // if serial empty, return to loop().

// parse incoming command start flag
get_char = Serial.read();
if (get_char != START_CMD_CHAR) return; // if no command start flag, return to loop().

// parse incoming command type
ard_command = Serial.parseInt(); // read the command

// parse incoming pin# and value
pin_num = Serial.parseInt(); // read the pin
pin_value = Serial.parseInt(); // read the value

// 1) GET TEXT COMMAND FROM ARDUDROID
if (ard_command == CMD_TEXT){
inText =””; //clears variable for new input
while (Serial.available()) {
char c = Serial.read(); //gets one byte from serial buffer
delay(5);
if (c == END_CMD_CHAR) { // if we the complete string has been read
// add your code here
break;
}
else {
if (c != DIV_CMD_CHAR) {
inText += c;
delay(5);
}
}
}
}

// 2) GET digitalWrite DATA FROM ARDUDROID
if (ard_command == CMD_DIGITALWRITE){
if (pin_value == PIN_LOW) pin_value = LOW;
else if (pin_value == PIN_HIGH) pin_value = HIGH;
else return; // error in pin value. return.
set_digitalwrite( pin_num, pin_value); // Uncomment this function if you wish to use
return; // return from start of loop()
}

// 3) GET analogWrite DATA FROM ARDUDROID
if (ard_command == CMD_ANALOGWRITE) {
analogWrite( pin_num, pin_value );
// add your code here
return; // Done. return to loop();
}

// 4) SEND DATA TO ARDUDROID
if (ard_command == CMD_READ_ARDUDROID) {
// char send_to_android[] = “Place your text here.” ;
// Serial.println(send_to_android); // Example: Sending text
Serial.print(” Analog 0 = “);
Serial.println(analogRead(A0)); // Example: Read and send Analog pin value to Arduino
return; // Done. return to loop();
}
}

// 2a) select the requested pin# for DigitalWrite action
void set_digitalwrite(int pin_num, int pin_value)
{
switch (pin_num) {
case 13:
pinMode(13, OUTPUT);
digitalWrite(13, pin_value);
// add your code here
break;
case 12:
pinMode(12, OUTPUT);
digitalWrite(12, pin_value);
// add your code here
break;
case 11:
pinMode(11, OUTPUT);
digitalWrite(11, pin_value);
// add your code here
break;
case 10:
pinMode(10, OUTPUT);
digitalWrite(10, pin_value);
// add your code here
break;
case 9:
pinMode(9, OUTPUT);
digitalWrite(9, pin_value);
// add your code here
break;
case 8:
pinMode(8, OUTPUT);
digitalWrite(8, pin_value);
// add your code here
break;
case 7:
pinMode(7, OUTPUT);
digitalWrite(7, pin_value);
// add your code here
break;
case 6:
pinMode(6, OUTPUT);
digitalWrite(6, pin_value);
// add your code here
break;
case 5:
pinMode(5, OUTPUT);
digitalWrite(5, pin_value);
// add your code here
break;
case 4:
pinMode(4, OUTPUT);
digitalWrite(4, pin_value);
// add your code here
break;
case 3:
pinMode(3, OUTPUT);
digitalWrite(3, pin_value);
// add your code here
break;
case 2:
pinMode(2, OUTPUT);
digitalWrite(2, pin_value);
// add your code here
break;
// default:
// if nothing else matches, do the default
// default is optional
}
}
[/code]

Ahora podemos enviar datos mas complejos y recibirlos en Arduino.

Veamos la Android App.  Debemos entender que datos vamos a recibir primero para poder enviarlos desde nuestro Android.

En este caso estamos usando un modulo BT HM10, que es mas avanzado porque soporta BT4.0 o Smart BT.  Para conectarse a un dispositivo de estos es un poco mas complicado porque utiliza un protocolo GATT para asegurar las conexiones y hacerlas mas eficientes.

Si oprimimos el primer botón OFF a ON, y luego lo apagamos seguido de mover el seek bar o slider RED hacia la derecha, podemos ver los resultados en el Serial Monitor:

Aquí vemos el comando que envía el Android al modulo HM10-BLE al oprimir el 1er botón: Pin2,1.  Luego vemos que envía el comando Pin2,0 al apagar nuevamente el mismo botón.  Esto se debe a que en la Android app le dimos ese valor para que enviara al ser oprimido.  Si ese primer botón es oprimido 1 vez, su estado cambia a ON, el color del botón cambia a Azul y envía el valor Pin2,1, lo cual deberemos parse o interpretar en nuestra app Arduino como enviar HIGH al Pin 2 por ejemplo, para encender una LED si quisiéramos.  De esta misma manera podemos controlar los siguientes pines usando un switch case como se ve en la aplicación de Hakim Bitar:

[code]
<pre>switch (pin_num) {
case 13:
pinMode(13, OUTPUT);
digitalWrite(13, pin_value);
// add your code here
break;
[/code]

Aquí vemos como si el numero de Pin es 13, entonces escribimos el valor, ya sea 1 u 0 a ese pin.  Para ellos solo necesitamos saber el numero de pin y el estado deseado (1 u 0).  Eso lo podemos obtener del texto enviado por la Android app: Pin2,0.

Luego el primer slider llamado RED envía el valor 0,0,0,71,0,0.  Esto se debe a que la app se baso en una app existente que traía 3 sliders, Red, Blue, Green.  Ellas enviaban los valores 0,0,0 cada vez que se movían hacia la izquierda o derecha.  Al moverse, el valor de cada uno de los 3 sliders era enviado al BLE, por ende se enviaba un arreglo con los 3 valores 0,0,0.  Nosotros queremos enviar valores para 6 sliders, los 6 PWM pins de la UNO.  Es por eso que nuestro arreglo es de 6 valores en lugar de 3.

Aqui esta la apk para Android:  hm10BT4LEDTest.apk

Corremos la app en el celular y podremos buscar dispositivos con BT y conectarnos a ellos y controlar una LED o motores etc!

Tutorial Sensor de Iluminación

En muchos casos queremos saber la iluminación disponible a nuestros robots.  Por ejemplo, a veces vamos a querer ejecutar ciertas acciones cuando hay poca luz, es decir que esta obscuro o de noche para encender luces o detectores.  Otras veces quizás necesitamos esperar a tener suficiente luz como para tomar fotos, cerrar cortinas o tomar una medición.  En este tutorial exploramos el uso de un sensor de luz o foto-transistor.

Requisitos:

1. Computadora (mac)
2. Arduino UNO
3. Resistor de 10kOhms
4. Foto-transistor TEMT6000
5. Breadboard y Jumpers
6. Arduino IDE (https://www.arduino.cc/en/Main/Software)

Como un buen transistor, este sensor consiste de un Colector, un Emisor y una Base.  En el caso del foto-transistor, la Base no la conectamos fisicamente a algún circuito ya que es la iluminación la que activa el circuito.  Este es el modulo en su mas sencilla expresión.  Es posible usar un breakout module que consiste del sensor montado en una pcb con conexiones mas accesibles como en este paquete:

Aquí vemos como se usa típicamente el sensor, junto con un Resistor.  Si ya contamos con este modulo en pcb lo podemos usar.  Si lo contamos con el sensor, veamos el diagrama para ver sus conexiones:

Debido a que solo vamos a usar el Colector y el Emisor, no es necesario conectar nada a la Base del foto-transistor.  Ahora soldaremos una cable delgado al pad del Emisor y otro al pad del Colector y lo conectamos todo así:

Finalmente corramos el sketch para tomar muestras:

[code]
void setup() {
Serial.begin(9600);
}
void loop() {
int value = analogRead(A0);
Serial.println(value);
delay(100);
}[/code]

Soldar los cables a los pads de un sensor así de pequeño es muy difícil pero con ayuda de tape para mantener el modulo inmóvil se puede lograr.  Los resultados son así:

Podemos ver como pasa de un valor 0V hasta 100V cuando se enciende la luz LED de un celular para iluminar el foto-transistor!

Esto es muy útil si estamos pensando en un proyecto de operación diurna o nocturna.  En nuestro caso lo usaremos para un proyecto de iluminación LED para la casa con detección de movimiento usando un PIR.