Arduino (IoT): Simple Tutorial Sensores T/H

Arduino Honduras Santiapps Marcio Valenzuela

Tutorial Sensores T/H

Hasta ahora hemos principalmente enviado informacion a los componentes.  Escribimos datos a una LCD, a motores y LEDs.  Ahora veamos como leer informacion de los componentes.

Requisitos:

  1. Computadora (mac)
  2. Arduino MEGA (u otra variante Arduino) o incluso Arduino clone, Edison, Raspberry…  Este tutorial en particular usa una Arduino MEGA.
  3. DHT11 Sensor de Temp/Humedad
  4. Breadboard
  5. Arduino IDE (https://www.arduino.cc/en/Main/Software)
Arduino Sensor Tutorial Santiapps Marcio Valenzuela

Arduino Sensor

 

La conexión es sencilla:

Arduino Sensor Tutorial Santiapps Marcio Valenzuela

Arduino Sensor

El pin de data, a la par del pin de 5V en el sensor, lo conectamos al pin 5 de la MEGA.  Este sera el pin que leeremos en codigo para obtener la data.

El codigo…

#include <dht.h>

dht DHT;

#define DHT11_PIN 5

void setup()
{
Serial.begin(9600);
Serial.println(“DHT TEST PROGRAM “);
Serial.print(“LIBRARY VERSION: “);
Serial.println(DHT_LIB_VERSION);
Serial.println();
Serial.println(“Type,\tstatus,\tHumidity (%),\tTemperature (C)”);
}

void loop()
{
// LEER DATA
Serial.print(“DHT11, \t”);
int chk = DHT.read11(DHT11_PIN);
switch (chk)
{
case DHTLIB_OK:
Serial.print(“OK,\t”);
break;
case DHTLIB_ERROR_CHECKSUM:
Serial.print(“Checksum error,\t”);
break;
case DHTLIB_ERROR_TIMEOUT:
Serial.print(“Time out error,\t”);
break;
case DHTLIB_ERROR_CONNECT:
Serial.print(“Connect error,\t”);
break;
case DHTLIB_ERROR_ACK_L:
Serial.print(“Ack Low error,\t”);
break;
case DHTLIB_ERROR_ACK_H:
Serial.print(“Ack High error,\t”);
break;
default:
Serial.print(“Unknown error,\t”);
break;
}
// DISPLAY DATA
Serial.print(“Hum”);
Serial.print(DHT.humidity, 1);
Serial.print(“,\t”);
Serial.print(“\n”);
Serial.print(“Temp”);
Serial.println(DHT.temperature, 1);

delay(2000);
}

Finalmente, la data.   La data la obtenemos del Monitor Serial asi:

Arduino Sensor Tutorial Santiapps Marcio Valenzuela

Arduino Sensor Tutorial Santiapps Marcio Valenzuela

DHT BRARY VERSION: 0.1.20

Type, status, Humidity (%), Temperature (C)
DHT11, OK, Hum36.0,
Temp32.0
DHT TEST PROGRAM
LIBRARY VERSION: 0.1.20

Type, status, Humidity (%), Temperature (C)
DHT11, OK, Hum36.0,
Temp32.0
DHT11, Checksum error, Hum36.0,
Temp32.0
DHT11, OK, Hum35.0,
Temp32.0
DHT11, OK, Hum34.0,
Temp32.0
DHT11, OK, Hum34.0,
Temp31.0
DHT11, OK, Hum34.0,
DHT11, Checksum error, Hum34.0,
Temp31.0
DHT11, OK, Hum33.0,
Temp31.0
DHT11, OK, Hum33.0,
Temp30.0
DHT11, OK, Hum35.0,
Temp29.0

Primero inicia midiendo el ambiente, luego el aire acondicionado enfria un poco el ambiente, finalmente pongo un vaso frío (con humedad).  Importante notar que a veces los sensores y/o la comunicación fallan y tenemos un Checksum Error.  Es importante tenerlo en cuenta para mas adelante para asegurarnos que contemplemos arreglos para esos casos a la hora de almacenar o utilizar o comunicar nuestra data.

Es sencillo no?  Con este esquema, si repasamos, básicamente siempre ocupamos un +, un – y uno o mas cables de data.  Veremos tutoriales de sensores mas avanzados pronto.  Por ahora repasemos el camino:

  • Dominamos escribir y leer electricidad a componentes.
  • Eventualmente vamos a tener que comunicar esa data desde nuestro robot a algun almacén mas permanente.
  • Para eso necesitamos componentes de comunicación.

Excelente!  Ahora estamos listos para aprender a comunicar data entre dispositivos.  Esta es la base para cualquier control remoto y definitivamente para cualquier robot decente!

Arduino (IoT): Simple Tutorial LCD

Arduino Honduras Santiapps Marcio Valenzuela

Tutorial LCD

Ya sabemos accionar luces y motores.  Ahora veamos como visualizar informacion en una pantalla LCD que es una tarea muy común para mostrar informacion obtenida de sensores.

Requisitos:

  1. Computadora (mac)
  2. Arduino MEGA (u otra variante Arduino) o incluso Arduino clone, Edison, Raspberry…  Este tutorial en particular usa una Arduino MEGA.
  3. Pantalla LCD
  4. Breadboard
  5. Arduino IDE (https://www.arduino.cc/en/Main/Software)

Una pantalla LCD es un componente un poco mas complicado.  Como pueden ver ya viene montado sobre una tarjeta de circuitos.  Pero no es de asustarse, una tarjeta de circuitos lo único que es, es una conexión de varios componentes de manera fija.  Es mas, en los tutoriales anteriores que hicimos interconexiones usando la breadboard, todos esos cables y resistores y diodos son exactamente eso.  La diferencia es que en una breadboard se ensaya y cuando ya se tiene un circuito bien probado, para no tener todos esos cables colgando, se reduce todo en tamaño y se fijan los cables a una tarjeta de circuitos.

En este caso la pantalla es sencilla (hay mas complicadas) pero lo mas importante es que tiene 16 pines que podemos ver en la esquina inferior derecha.  Estan nombrados:

– VSS, VDD, VO: VDD (+), VSS (-) & V0 (contraste)

– RS, RW, E: RS (registro), RW (Read/Write) & E (enable)

– D0 – D7: D0-D3 (no data), D4-D7 (data)

– A & K: A (backlight) & K (backlight GND)

 

 

Arduino LCD Tutorial Santiapps Marcio Valenzuela

Arduino LCD

 

Las conexiones aquí se vuelven un poco mas complicadas asi que prepárense.  Si hay una conexión mas sencilla ahora utilizando un protocolo llamado I2C pero siempre es bueno empezar por lo tradicional y crecer desde allí.

Arduino LCD Tutorial Santiapps Marcio Valenzuela

Arduino LCD

Se mira complicado pero no lo es.  Vamos por partes:

  • Primero alimentamos la breadboard con 5V de la MEGA (cable rojo superior izquierdo) y con el GND (cable negro en el centro de la imagen).  Esto es VSS y VDD.
  • Luego un cable azul pequeño en el breadboard conecta al 3er pin en el LCD denominado V0.  Este dijimos que es el contraste.  Es común que las LCDs tenga un controlados de contraste ya que dependiendo de la luz ambiental se puede ver mejor si se ajusta el mismo.  Esto se hace variando la corriente al LCD y ya sabemos que para variar la corriente con un dial, un pot es ideal.
  • Ahora viene un cable rojo vino del pin 12 de la MEGA (RS), un cable negro al GND (R/W) y un cable blanco al pin 11 de la MEGA (E).
  • Luego los pines D0-D3 están libres en este caso.
  • Siguen los 4 pines de datos que se conectan a los pines 2-5 del LCD. (NOTA: usar 4 pines es equivalente a usar el LCD en modo 4-bits y usar los 8 pines es usarlo en modo 8-bits)
  • Finalmente tenemos un resistor al 5V en el backlight (A) y el GND al backlight GND (K).

La alimentacion de VSS y VDD no necesita explicación, es la fuente de poder para la LCD.  La alimentación para el backlight, A & K, tampoco.  Los 4 pines de data es donde enviaremos la data y los 4 pines vacíos pues no hay nada que explicar.  El pin V0 al pot es para regular el contraste.

Lo único que requiere explicación es RS, RW y E.

RS determina si la LCD esta en modo instrucción o caracteres.  En modo instrucción la LCD responde a comandos como limpiar el display o mover el cursor.  A diferencia del modo caracteres que dice a la LCD que reciba data tipo alfanumerica o de símbolos.  Si el RS esta a voltaje bajo o GND, esta en modo instrucción.  Si esta a voltaje alto o 5V esta en modo caracteres.

RW es similar y la distincion radica entre modo de lectura del display (READ) o modo de escritura al display (WRITE).  Read es poco comun pero existe.  Nosotros principalmente estaremos usando el modo write.

Finalmente, E, habilita y deshabilita los dos RS y RW.  Es decir, cuando E tiene voltaje bajo, RS y RW no importan, la LCD no recibe data.  Cuando E recibe voltaje alto entonces lee datos entrantes.

Bueno suficiente explicación, ahora veamos la conexión:

Arduino LCD Tutorial Santiapps Marcio Valenzuela

Arduino LCD Tutorial Santiapps Marcio Valenzuela

Parece complejo pero es tan sencillo como el diagrama que vimos arriba con algunas modificaciones.

De derecha a izquierda

El primer par rojo/negro (err: en la imagen falta el cable negro) es el que alimenta de la MEGA.  El segundo par rojo/negro que sale hacia la esquina inferior derecha son los que alimentan el pot.  El tercer par rojo/negro son los que entran directamente al LCD en sus pines VDD/VSS.  Luego viene el cable verde en la LCD que va al wiper del pot.  Le sigue el cable verde (RS) al pin 12, cable negro(RW) a GND comun y otro cable verde(E) al pin 11.  A continuacion los 4 pines vacios seguidos de los 4 pines (D4-D7) con cables de data.  Finalmente esta el ultimo par rojo/negro a los pines A/K respectivamente.  En resumen deberiamos tener:

LCD -> MEGA -> Breadboard -> Color de Cable –> Otro

VSS –> GND —>  SI ————-> Negro

VDD –> 5V ——> SI ————–> Rojo

V0 ——————> NO ————> Verde —————> Wiper del Pot

RS —–> 12 ——> NO ————> Verde

RW —-> GND —> SI ————–> Negro

E ——-> 11 ——> NO ————> Verde

D0-D3

D4-D7 -> 5-2 ————————-> 5&4 naranja, 3&2 amarillos

A ——-> 5V ——-> SI ————-> Rojo

K ——-> GND —-> SI ————-> Negro

Finalmente el codigo:

//#include <SPI.h> // Esta no la usaremos, es para LCDs con una conexión distinta pero mas avanzada
#include <LiquidCrystal.h>
// initializamos el objeto LiquidCrystal, similar como el Servo
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
// Nuestro LCD es 16 cols x 2 filas
lcd.begin(16, 2);
// Imprimimos al LCD
lcd.print("Hola Arduino HN!");
}
void loop() {
// Cada loop reseteamos el cursor a col0, linea1
// linea 1 es la 2da fila porque linea 0 es la primera
lcd.setCursor(0, 1);
// Imprimimos segundos desde reinicio...
lcd.print(millis() / 2000);
delay(1000);
}

Y ahora el resultado final…bueno, al menos el mio…

Arduino LCD Tutorial Santiapps Marcio Valenzuela

Arduino LCD

 

Arduino LCD Tutorial Santiapps Marcio Valenzuela

Arduino LCD

Ok, repasando lo que aprendimos:

  • Aprendimos a usar componentes con varios pines.
  • Tenemos una manera mas amigable para visualizar la data de un proyecto en una pantalla.

Ahora podemos relacionar esto al uso de una pantalla mas sofisticada como una TFT para ver mas datos o incluso TFT touchscreen que nos permite una interacción intuitiva entre el usuario y la data.

En el proximo tutorial aprenderemos a leer data de un sensor.  La idea es comenzar a trabajar con componentes mas sofisticados y con libraries para ir conectándolos de manera que podamos incorporar a nuestro proyecto de datos, la comunicación de esos datos.

Arduino (IoT): Simple Tutorial Motores DC & Servos

Arduino Honduras Santiapps Marcio Valenzuela

Tutorial Motores

Ya sabemos controlar flujo de electricidad a luces.  Ahora lo vamos a hacer con motores.  Al igual que con luces hay algunos detalles importantes.

Requisitos:

  1. Computadora (mac)
  2. Arduino MEGA (u otra variante Arduino) o incluso Arduino clone, Edison, Raspberry…  Este tutorial en particular usa una Arduino MEGA.
  3. Motor DC & Servo
  4. Breadboard
  5. Arduino IDE (https://www.arduino.cc/en/Main/Software)

Terminología

Motor DC es un tipo de motor continuo.  Es decir que rota continuamente o infinitamente en la misma dirección.

Motor Servo es un tipo de motor que gira o rota de manera escalonada dependiendo del valor eléctrico pasado al mismo.

 

Arduino DC Servo Motors Santiapps Marcio Valenzuela

Arduino DC & Servo Motors

Comencemos sencillo.  Vamos a conectar primero 1 motor DC a la MEGA y usaremos el Monitor Serial para enviar datos de electricidad a la MEGA para determinar cuanta enviar al motor.

Conozcamos los componentes

Que son estos 3 componentes extraños?

Arduino Motor Tutorial Santiapps Marcio Valenzuela

Arduino Motor

El primero de arriba a abajo es el transistor.  El de en medio lo habíamos usado antes y es un resistor.  El de abajo es un diodo.

Un transistor…

Un Resistor resiste el flujo de corriente en el circuito.

Un diodo controla que el flujo eléctrico solo avance en una dirección.

Ahora entendamos el circuito.

:

Arduino Motor Tutorial Santiapps Marcio Valenzuela

Arduino Motor

Primero veamos el bosque. La corriente fluye de la MEGA 5V por el cable naranja que cruza del centro a la derecha de la imagen.  El cable amarillo cierra el circuito, GND.  El otro cable naranja sale del pin 3 de la MEGA hacia la breadboard.

Veamos estas conexiones en mayor detalle:

Arduino Motores Tutorial Santiapps Marcio Valenzuela

Arduino Motores

Ok, comencemos con la 5V proveniente de la MEGA.  Este cable conecta en la fila 5 de la breadboard (tiene una manga negra en cada punta).  Aquí mismo conecta a la terminal (+) del motor.  Aquí también hace conexión con el diodo, el cual restringe el flujo en una sola dirección.

Luego ese flujo pasa al transistor en una de sus patas extremas que resulta estar conectada a la terminal (-) del motor.  La otra pata del transistor se conecta al cable amarillo proveniente del GND en la MEGA.  Esto deja unicamente la pata central del transistor.  Esta se conecta al resistor quien hace la conexión al pin 3 de la MEGA.

El código es lo mas simple:

int motorPin = 3; // definimos el pin 3 en la MEGA como el del motor
void setup() {
pinMode(motorPin, OUTPUT);  //declaramos ese pin de tipo output
Serial.begin(9600);         // iniciamos el monitor serial
while (! Serial);           // mientras no hay nada en serial, imprimimos un mensaje
Serial.println("Speed 0 to 255");
}
void loop() {
if (Serial.available()){    // Si hay un valor en el Serial, lo leemos...
int velocidad = Serial.parseInt();  //convertimos a un int almacenado en velocidad
if (velocidad >= 0 && velocidad <= 255) // Si dicho valor esta entre 0 y 255...
{
analogWrite(motorPin, velocidad); // lo escribimos al pin del motor
}
}
}

Aquí el video:

Ahora cambiemos el tipo de motor…conozcamos al servo-motor.  Un servo no genera rotación continua sino discrecional y en valores concretos.  Es decir, en lugar de usar la corriente para girar el motor hasta que se retire la corriente, un servo es mas preciso y puede girar exactamente una cantidad determinada dependiendo de la corriente enviada.  Hay servos que giran 180 grados en una dirección y luego 180 en la dirección contraria.  Estos son los mas comunes pero no son los únicos ya que también hay servo motores que giran 360 grados y se usan comúnmente en juguetes como robots y carros.

Hagamos girar un servo-motor y luego podremos jugar un poco con un…juguete. :-)

Podríamos usar un setup como este:

Arduino Servo Tutorial Santiapps Marcio Valenzuela

Arduino Servo

Aqui vemos como usar el pot para controlar el servo.  Los 5V van al + del pot y la GND va al – del pot.  Habíamos visto que el pin central del pot es el que genera la señal de cuanta corriente fluye dependiendo del dial.  Es decir que aqui lo que hariamos es leer el pin analogo y escribir al pin digital.  De hecho aqui esta el sketch para este proyecto:

#include <Servo.h> 
Servo myservo;  // Creamos objeto servo 
int potpin = 0;  // definimos A0 como pin del pot
int val;    // variable para almacenar valor del pot 
void setup() {
myservo.attach(9);  // Pegamos el servo al pin digital 9
}
void loop() {
val = analogRead(potpin);            // Leemos el pot (valor de 0 – 1023) 
val = map(val, 0, 1023, 0, 179);     // Mapeamos al servo (valor de 0 – 180) 
myservo.write(val);                  // Escribimos valor al servo 
delay(15);                           // Esperamos un rato para volver a empezar 
}

Lo único nuevo aquí, aparte del hecho que un servo tiene un cable adicional, que es el cable que recibe la señal, es que el servo utiliza una library.  Una library no es mas que un set de código adicional que nos permite interactuar con alguna objeto. En este caso el objeto es Servo y lo creamos en la primera linea del código.  Crear ese objeto en código lo que hace es:

  1. Ir al codigo de la library Servo.h y crear un objeto en codigo usando la plantilla del objeto Servo.  Crear uno de estos objetos en codigo nos da propiedades de ese objeto que podemos modificar y funciones de ese objeto que podemos usar.  Por ejemplo la función write que usamos al final nos permite escribir el valor de corriente que queremos al objeto Servo.
  2. Una vez creado uno de estos objetos en código, interactuar con ese objeto es mas sencillo.  Podemos usar funciones como .attach() para conectar el servo real en pin 9 al objeto servo virtual que acabamos de crear.  Otra función es la de .write().  Esta función que esta en la Servo library es un set de instrucciones como nuestra función setup() o loop() que define que hacer con los valores que ponemos adentro de los paréntesis write() para que se conviertan en una señal eléctrica que activen el motor.

Es importante familiarizarnos con libraries y sus métodos porque lo estaremos usando en los siguientes tutoriales que involucran LCDs y comunicaciones usando distintas tecnologías.  De hecho las libraries se vuelven complicadas porque hay distintas versiones para una misma library que tienen pequeñas variaciones y a veces pueden hacer que nuestro código falle.  Pero eso lo veremos en su momento.

Ok, repasando lo que aprendimos:

  • Convertimos aquella LED en un motor.  Lo mismo aplicaría para cerrojos o válvulas de flujo.
  • Convertimos el flujo eléctrico repetitivo a uno condicionado por input del usuario, ie: el ingreso de un valor al Monitor Serial.  Ese input del usuario podría venir de una conexión BT, Wifi, GPRS, NFC etc.
  • O aun mas interesante, en lugar de un usuario que debe accionar el sistema, la condición puede venir del resultado computado de un sensor de luz, sonido, calidad de aire, temperatura, huella digital etc…

En el proximo tutorial exploraremos LCD’s para visualizar información de una manera mas amigable.

Arduino (IoT): Tutorial de Carro Juguete

Arduino Honduras Santiapps Marcio Valenzuela

Tutorial Juguete

Hemos visto como controlar la electricidad.

Requisitos:

  1. Un carro electrónico o a control remoto
  2. Un voltimetro o amperimetro (incluso puede ser un simple cable)

En juguete electrónico como un carro de baterías no es mas que una tabla de circuitos integrados con una fuente de poder (las baterías AA tipicamente).  El programa para esa tarjeta ya esta cargado en la fabrica y lo único que hace ese programa es controlar el flujo eléctrico a los componentes del carro.

Yo tengo a mi disponibilidad por los momentos este carro:

Arduino Tutorial Toy Car Santiapps Marcio Valenzuela

Arduino Toy Car

Este por suerte es un carro sencillo porque no es a control remoto, solo tiene botones (3 color naranja en la parte superior trasera) que cumplen ciertas funciones.  Por ende lo que dispara el programa grabado en el chip de este juguete es la accion de completar algun circuito con uno de esos 3 botones.  Un circuito activa solo el sonido, otro activa solo las luces y un tercero activa los botones, luces, sonido y el motor!

Veámoslo por dentro:

Arduino Tutorial Toy Car Santiapps Marcio Valenzuela

Arduino Carro

Lo importante a notar aquí es que hay una placa electronica (cafe en el lado derecho) que esta pegada a la parte superior del carro, la tapadera.  Esa placa tiene cables que van hacia la tarjeta principal.  La función de esa placa de completar los circuitos usando los botones naranja de afuera.  En el lado izquierdo podemos ver en la parte superior, un motor DC que mueve las llantas.

Arduino Tutorial Toy Car Santiapps Marcio Valenzuela

Arduino Tutorial Toy Car

Y en la parte inferior de la imagen izquierda podemos ver la placa principal (color blanco) con un parlante para el sonido y unas cuantas terminales visibles de la tarjeta de circuitos.

Arduino Tutorial Toy Car Santiapps Marcio Valenzuela

Arduino Tutorial Toy Car

Aquí podemos ver varios componentes de cerca y lo que mas llama la atención es la fila horizontal de terminales con letras PXX & GND.  Sabemos que solo es cuestión de completar un circuito.  Si recuerdan en todos los totorales que hemos visto hasta ahora, todos tienen pines distintos pero comparten 1 pin en común…GND!

Así que cerremos el circuito entre GND y cualquiera otra terminal a ver que pasa.  Será divertido!  Lo pueden hacer con las dos terminales de un voltímetro pero también lo pueden hacer con un cable.  Lo importante es completar el circuito.

Algo importante a notar es lo siguiente.  Primero se intenta cerrar un circuito uniendo P00 con P01, luego P00 con P02 y P03.  Eso claro no tiene lógica.  Seria como querer conectar un pin 2 con pin 3 en la MEGA.  Claro que no completara ninguna circuito.  Necesitamos el pin de GND para cerrar cualquier circuito.

Bueno hoy fue un break.  Solo repasamos el concepto general de completar circuitos.  Es importante recordar que eso es todo lo que estamos haciendo.

Nos vemos en la proxima!

Saving HealthKit Data & Closures

iOS 8 HealthKit Santiapps Marcio Valenzuela

iOS 8 HealthKit

This code bit saves:

  healthKitStore.saveObject(bmiSample, withCompletion: { (success, error) -> Void in
    if( error != nil ) {
      println("Error saving BMI sample: \(error.localizedDescription)")
    } else {
      println("BMI sample saved successfully!")
    }
  })

The method signature is:

saveObject(object: HKObject!, withCompletion completion: ((Bool, NSError!) -> Void)!)

This method takes an HKObject which is bmiSample

and it takes a completion closure which itself takes a bool & error and returns void.

So in our method call, we pass in the bmiSample as the HKObject and for the success and error completion block we say:

if error is NOT nil then log that error’s description,

else log that the bmiSample was saved successfully.

 

 

This code bit reads:

// 2. Call the method to read the most recent weight sample
self.healthManager?.readMostRecentSample(sampleType, completion: { (mostRecentWeight, error) -> Void in
 
  if( error != nil )
  {
    println("Error reading weight from HealthKit Store: \(error.localizedDescription)")
    return;
  }
 
  var weightLocalizedString = self.kUnknownString;
  // 3. Format the weight to display it on the screen
  self.weight = mostRecentWeight as? HKQuantitySample;
  if let kilograms = self.weight?.quantity.doubleValueForUnit(HKUnit.gramUnitWithMetricPrefix(.Kilo)) {
    let weightFormatter = NSMassFormatter()
    weightFormatter.forPersonMassUse = true;
    weightLocalizedString = weightFormatter.stringFromKilograms(kilograms)
  }
 
  // 4. Update UI in the main thread
  dispatch_async(dispatch_get_main_queue(), { () -> Void in
    self.weightLabel.text = weightLocalizedString
    self.updateBMI()
 
  });
});

Here we are calling the .readMostRecentSample method which has this signature:

func readMostRecentSample(sampleType:HKSampleType , completion: ((HKSample!, NSError!) -> Void)!)

This method takes an HKSampleType which is sampleType

and it takes a completion closure which itself takes an HKSample & error and returns void.

So in our method call, we pass in the sampleType as the HKSample and for the success and error completion block we say:

if error is NOT nil then log that error’s description,

else get that mostRecentWeight as self.weight, format it and set it as the label’s text.

How does this method get the actual value from the HKHealthStore?  Inside itself, it executes an HKQuery which itself says this:

let sampleQuery = HKSampleQuery(sampleType: sampleType, predicate: mostRecentPredicate, limit: limit, sortDescriptors: [sortDescriptor])
    { (sampleQuery, results, error ) -> Void in
 
      if let queryError = error {
        completion(nil,error)
        return;
      }
 
      // Get the first sample
      let mostRecentSample = results.first as? HKQuantitySample
 
      // Execute the completion closure
      if completion != nil {
        completion(mostRecentSample,nil)
      }
  }
  // 5. Execute the Query
  self.healthKitStore.executeQuery(sampleQuery)

Give me:

a.  sampleType

b.  a predicate, limit, sortDescriptors

c. and a completion closure which takes a sampleQuery, results & error

such that;

if error it NOT nil, set the readMostRecentSample method’s completion closure to nil,error

otherwise set the completion closure with the results and no error.

Arduino (IoT): Tutorial de Potenciómetros y Botones

Arduino Honduras Santiapps Marcio Valenzuela

Tutorial Pots & Botones

Ya sabemos escribir electricidad a un pin.  Ahora vamos a aprender a leer la electricidad de un pin.  Aprenderemos la diferencia entre un pin análogo vs digital.  Finalmente afinaremos nuestro control de la electricidad usando botones y potenciómetros.

Requisitos:

  1. Computadora (mac)
  2. Arduino MEGA u otra.
  3. LED
  4. Breadboard
  5. Arduino IDE (https://www.arduino.cc/en/Main/Software)
  6. Potenciómetro
  7. Botones
Arduino Pot Santiapps Marcio Valenzuela

Arduino Pot

 

 

Componentes

Pot (azul en esquina superior derecha) es un dial mecánico que permite el flujo de electricidad a través del mismo pero con variable resistencia al flujo.  Es decir, en un extremo la electricidad fluye con facilidad mientras que en el otro extremo la misma fluye con mucha resistencia.

Boton (negro en equina inferior derecha) es un dispositivo mecánico que abre o cierra un circuito, interrumpiendo el flujo de electricidad.

Pines Análogos vs Digitales varían debido a que un pin análogo recibe señales de dispositivos análogos.  Los digitales reciben señales de dispositivos digitales y a veces hasta pueden variar la cantidad de electricidad que fluye en pulsos.

Vamos a continuar con el circuito del primer tutorial.  En aquel proyecto, el flujo de electricidad a la LED variaba en función a retrasos de 1 segundo que eran en sí controlados por el método loop que corre indefinidamente.  Ahora vamos a controlar el flujo eléctrico hacia una LED (verde) a través de un potenciómetro y un botón.

Primero agregamos un botón…

Arduino Boton LED Santiapps Marcio Valenzuela

Arduino Boton LED

Primero veamos los pines de la MEGA.  El pin 13 & GND de la parte superior conectan un LED verde.  Enviaremos corriente a este pin 13 a traves del circuito que armaremos ahora en el breadboard.

La breadboard recibe 5V via el cable naranja de la izquierda que baja y entra por la esquina inferior derecha.  Esto reparte la corriente a lo largo de la columna (+) que es donde el resistor entra en juego (reduciendo el potencial eléctrico del circuito) en la fila 15.  Luego se interconecta al cable naranja central que esta conectado al pin 2 de la MEGA.  Finalmente el mismo esta conectado al switch que hace un puente hacia la fila 13 donde conecta al cable amarillo que sale al GND de la MEGA.

En resumen, el circuito eléctrico es de la MEGA a la breadboard (atravesando el resistor, cable naranja central y el switch) y sale al terminal GND de la MEGA.  Ese circuito tiene un potencial de 5V y esta controlado por un switch.  El switch decide si el circuito se abre o cierra.  El switch tiene 2 valores posibles: 0 o 1.  Dependiendo del estado del boton (0 o 1), encendemos la LED en pin 13.  Este es el codigo:


int d=2; // Iniciamos una variable para el estado del boton
void setup(){
pinMode(2,INPUT); //Queremos recibir datos en el pin 2 - datos del boton
pinMode(13,OUTPUT); //Queremos enviar datos al pin 13 - donde esta nuestro LED
}
void loop(){
d=digitalRead(2);          // Aqui leemos el boton en pin 2
if(d==0){                        // Si el valor es 0, esta apagado...
digitalWrite(13,HIGH);} //Escribamos corriente
else {                            // Si no es 0, es seguramente 1, esta encendido...
digitalWrite(13,LOW);  //Apaguemoslo
}
}

Aqui esta el video final:

Ahora veamos porque y como funciona esto.  Leamos los datos del boton en algo llamado el Serial Monitor.  Resulta que el interfaz entre USB y la MEGA se hace a través de un protocolo llamado Serial (es decir, los datos se transmiten en serie).  Veamos los datos que fluyen entre la MEGA y la computadora.  Para esto podemos imprimir datos a la pantalla del serial monitor para verificarla.  Para ello debemos inicializar el monitor en el método setup() usando:

Serial.begin(9600);

y luego imprimir el valor deseado en el método loop() usando:

Serial.println(elvalor);

Para poder obtener elvalor del botón solo hace falta hacer esto en el método loop():

int elvalor = digitalread(boton);

El codigo final se miraría asi:

int d=2; // Asignemos un valor a una variable donde escribiremos el estado del boton
void setup(){
Serial.begin(9600); // Inicializamos el monitor serial
pinMode(2,INPUT); //Queremos recibir datos en el pin 2 - datos del boton
pinMode(13,OUTPUT); //Queremos enviar datos al pin 13 - donde esta nuestro LED
}
void loop(){
int elvalor = digitalRead(2); // Aqui leemos el boton en pin 2
//d=digitalRead(2); << esta linea esta comentada, osea no se compila
Serial.println(elvalor); // Imprimimos el estado del boton
if(elvalor==0){ // Si el valor es 0, esta apagado...
digitalWrite(13,HIGH);} //Escribamos corriente
else { // Si no es 0, es seguramente 1, esta encendido...
digitalWrite(13,LOW); //Apaguemoslo
}
}

Al correr este código, ademas de funcionar el botón con la LED, vemos el valor para el estado del botón en el Serial Monitor que podemos abrir (luego de cargar y correr el programa) haciendo click en este botón de la esquina superior derecha que tiene un ícono de lupa:

Arduino LED Boton Santiapps Marcio Valenzuela

Arduino LED Boton Santiapps Marcio Valenzuela

Los resultados en el Monitor Serial se verán así:

Arduino LED Boton Santiapps Marcio Valenzuela

Arduino LED Boton Santiapps Marcio Valenzuela

Cuando el programa inicia, el estado del botón es 2, pero inmediatamente que corre el loop, su valor cambia a 1.  Cuando oprimimos el botón, su valor cambia a 0.  La LED continua funcionando igual que antes.

Ok ahora veamos el uso de un pot, o potenciómetro.  Este dispositivo varía el voltaje en un circuito según se gira el dial.  Esto es en función del recorrido que debe hacer la corriente del punto de entrada al punto de salida.  Un pot tiene tres pines o conectores como se ve abajo:

Arduino Potenciómetro Santiapps Marcio Valenzuela

Arduino Potenciómetro

La corriente entra por A y sale por B.  Cuando el Wiper (B) esta cerca del punto 1, el diferencial de potencial es 0 (el diferencial entre A y W1-rojo es cero.  Según se mueve el wiper hacia 2, el diferencial de potencial sube.  Continua subiendo en 3 y alcanza su máximo en W1-azul, ósea a la derecha.

Hagamos una conexión sencilla:

Arduino Pot Santiapps Marcio Valenzuela

Arduino Breadboard

Aquí vemos el pot (el cual tiene 3 pines) conectado en la breadboard en las filas 9,10 y 11.  Esto significa que el pin central (el del wiper) esta en el pin 10.  El 9 y el 11 se conectan al 5V y GND en cualquier orden, no importa.  Recordemos que el wiper hace el circuito cortarse entre 0 y 5V dándonos la lectura deseada.

Es por ello que el pin 10 sale del pot y se conecta al pin analogo A0 como veremos en la siguiente imagen.  Por lo demás, es sencillo ya que el pot conecta al cable amarillo que representa el GND en su pin 9 y conecta al cable naranja que va al 5V de la MEGA.  Luego en el lado derecho tenemos el circuito de la LED donde el GND conecta a la pierna corta de la LED a traves del cable negro y la pierna larga de la LED conecta, a traves del resistor, al cable naranja que va al pin 12 de la MEGA.

Arduino Pot Santiapps Marcio Valenzuela

Arduino Pot MEGA

Es decir que nosotros leeremos lo que sale del pot, a través del cable verde (pin A0) y en código convertiremos esa data a valores que podemos usar para enviar electricidad a la LED.  Esto lo hacemos en código a través de la función de mapeo.  La función map hace un mapeo entre los valores posibles para el pin serial del pot (1024) a los valores posibles para el pin serial de la LED (256).  Esto resulta en un cambio en la electricidad enviada al pin 12 y por ende la intensidad de la LED.

Ahora veamos como leer este potencial usando un código (sketch) muy sencillo.

void setup() {
Serial.begin(9600);
pinMode(12, OUTPUT); // declaramos que pin 12 es de salida
}
void loop() {
int intensidad = analogRead(A0); // Almacenar el valor analogo del pot en intensidad
intensidad = map(intensidad, 0, 1023, 0, 255); // Mapea el valor de pot (0-1023) al rango LED (0-255)
Serial.println(intensidad); // Ver el valor en serial monitor.
analogWrite(12, intensidad); // Escribir el nuevo valor de intensidad al LED en pin 12
}

Sencillo no?  Aqui un video:

http://youtu.be/wMdvCr7WcCU

Veamos lo que podemos hacer hasta ahora:

  • Escribir electricidad a un pin para controlar un componente
  • Leer electricidad de un pin para saber su estado
  • Regular electricidad en un pin via analoga (usando un pot o boton) y via digital usando el código

Ahora vamos a hacer que estos controles nos sean mas amigables para poder controlar con mayor facilidad componentes mas sofisticados!  Vamos con motores!

Arduino (IoT): Simple Tutorial LED

Arduino Honduras Santiapps Marcio Valenzuela

Tutorial LED

La idea es sencilla.  Usaremos coding de computadora para controlar el flujo de electricidad.  En este tutorial aprenderemos como controlar el flujo de electricidad hacia una LED desde una micro controller board.

Requisitos:

  1. Computadora (mac)
  2. Arduino MEGA (u otra variante Arduino) o incluso Arduino clone, Edison, Raspberry…  Este tutorial en particular usa una Arduino MEGA.
  3. LED
  4. Breadboard
  5. Arduino IDE (https://www.arduino.cc/en/Main/Software)

(Si solo quieren ir a ver como se conecta todo, vayan al MARCADOR)

Terminología

Breadboard es un tablero de filas y columnas de agujeros.  Esta matriz de agujeros se usa para interconectar componentes electrics sin usar tanto cable.

Arduino MEGA es una micro controller board.  Hay muchas otras pero basicamente escribimos coding para decirle al microchip en la board como administrar la electricidad.  El codigo dice cuando, cuanta y adonde enviar la electricidad.

Arduino Honduras Santiapps Marcio Valenzuela

Arduino LED setup

La LED es la luz en la bolsa del centro.

La cosa rara en la derecha es un resistor.  Básicamente cuando se quiere regular el flujo de electricidad en un circuito se usa un resistor.  En este caso necesitamos asegurarnos que no mucha electricidad fluya ya que podia quemar la LED porque son componentes bien sensibles.

Antes de iniciar entendamos como se arma un proyecto Arduino.  Básicamente funciona así:

  1. La computadora se usa para escribir y subir el codigo al micro controller board y al mismo tiempo para suplir electricidad a ella.
  2. Las conexiones electricas se hacen entre la micro controller board y los componentes a controlar.

Veamos la board:

Arduino Honduras Santiapps Marcio Valenzuela

Arduino MEGA

El puerto metallic en la izquierda superior es para el cable USB.  Este es el interfaz entre la computadora y la board (MEGA).  Este puerto se usa para subir el coding a la MEGA y proveerla de electricidad.

Adicionalmente, cuando un proyecto esta listo para hacerlo móvil, ya no es necesario que opere conectado a la computadora.  Es decir, la MEGA y sus componentes pueden seguir operando ya que las instrucciones están en la MEGA.  Sin embargo siempre es necesario suplir electricidad a la MEGA y sus componentes.  Para esto se usa el puerto tambor negro en la esquina inferior izquierda.  Aqua se puede conectar battery packs para suplir energía al proyecto móvil.

Si se fijan hay varios pines alrededor de las orillas de la MEGA.  Estos son los pines por donde la MEGA puede enviar electricidad a los componentes.  En este caso la MEGA cuenta con:

– 16 pines análogos (A0-A15)

– 54 pines digitales (de los cuales algunos están dedicados a comunicación y otros son PWM

Este proyecto es muy pequeño para una MEGA pero mi UNO esta ocupada con un proyecto mas complejo.

Entonces la idea seria, recibir electricidad de la USB, pasarla al pin donde este conectado el LED y mandar instrucciones para controlar ese pin.

(A)  Podríamos conectar todo así:

Arduino Honduras Santiapps Marcio Valenzuela

Conexión LED

pero hay 2 problemas: (1) que no podríamos controlar la cantidad de electricidad que fluye al LED y (2) la conexión de la LED seria inadecuada y podría aflojarse.

(B)  Típicamente se usa una conexión con cables sin-soldar como estos:

Arduino Honduras Santiapps Marcio Valenzuela

Conexión con cables sin-soldar

pero en este caso particular que necesitamos otro componente en el circuito (el resistor), se complicaría agregarlo.  Es por eso que usamos las breadboards:

Arduino Honduras Santiapps Marcio Valenzuela

Breadboard

(C)  Una breadboard tipicamente tiene columnas principales, donde reciben electricidad.  Aquí están marcadas con un + para positivo y un – para negativo. Es decir que estas columnas deben recibir la electricidad de la MEGA.

En esta imagen la fila positiva provee una conexión + a través del cable naranja.  Aquí esta conectado a la fila 16.  Es decir que la fila 16, lo cual incluye columnas:

16-a, 16-b, 16-c, 16-d y 16-e

esta conectados al polo positivo del circuito.

Asi mismo el polo negativo sale a través del cable amarillo hacia la fila 14, lo cual incluye las columnas:

14-a, 14-b, 14-c, 14-d y 14-e

Esto significa que podríamos hacer algo asi:

Arduino Honduras Santiapps Marcio Valenzuela

Breadboard

Ojo, la pata mas larga del LED es la +.  En este caso la estariamos conectando a la fila 16 donde esta el polo positivo (cable naranja).  Y la pata – en el polo negativo alimentado por el cable amarillo.  Sin embargo dijimos que en el caso particular de un LED, es necesario incorporar un resistor.  El uso de la breadboard nos facilita esto:

Arduino Honduras Santiapps Marcio Valenzuela

Resistor

Esta conexión se representa con un diagrama que puedes generar con un programa gratuito llamado Fritzing (http://fritzing.org/).  Un diagrama generado se mira así:

Arduino LED Santiapps Marcio Valenzuela

Arduino Fritzing

Aquí ya aparece la MEGA conectada a la breadboard.  Como pueden ver, sacamos corriente del pin etiquetado 5V (+) y se cierra el circuito con el pin etiquetado GND (-).  Esta board (MEGA) y la mayoría de los componentes para estos proyectos usan 5V.  Algo importante aquí es que el momento que conectamos estos componentes en esta forma, al conectar la MEGA a la computadora via USB, la corriente fluye de la computadora a la MEGA y directo a la LED porque usamos el pin 5V, el cual siempre da corriente.  La idea es precisamente usar otro pin, que no siempre da corriente, y poder controlar el flujo de la corriente a ese pin.  Si revisan la imagen original, queríamos que ese fuera el pin 12.  Asi que en nuestro caso, el diagrama se mirara asi:

Arduino

MARCADOR

Repasando que vamos a hacer:

  1. El polo positivo entra de la MEGA por el cable naranja y se conecta a la fila 16, la cual alimenta la pata larga (+) de la LED.
  2. El polo negativo entra de la MEGA por el cable amarillo y se conecta a la fila 14 via el resistor (controlando el flujo) y luego a la pata corta (-) de la LED.

Les podría parecer raro que el resistor este en la pata negativa.  Solemos creer que la electricidad fluye de + a -.  De hecho no importa en este caso porque el circuito se cierra y la electricidad comienza a fluir.  El resistor controla ese flujo sin importar en que dirección.  (Y de hecho la electricidad fluye de – a +).

Ok, estamos listos para ver el código que controlara el flujo de la MEGA a la breadboard:

// Conectamos la LED al pin
int led=12;
// Este método corre una vez, al inicio únicamente
void setup(){
// Aqui inializamos el pin 12 de tipo OUTPUT - para mandarle corriente
pinMode(led,OUTPUT);
}
// Este metodo corre infinitamente, repetitivamente, varias veces x segundo, asi que cuidado lo que pongan aquí porque puede atascar todo
void loop(){
digitalWrite(led,HIGH);// primero mandamos corriente al pin 12
delay(1000);// esperamos 1 segundo (1,000 milisegundos)
digitalWrite(led,LOW);// luego quitamos la corriente al pin 12
delay(1000);// esperamos otro segundo
}                                       // y el ciclo se repite

Sencillo no?  Esto hará que la LED se encienda y apague cada segundo.  Ahora solo resta hacer las conexiones, conectar el cable USB a la computadora y a la MEGA y subir el código.  Aqui un video del proyecto final:

El proyecto final se mira así:

Arduino LED

Arduino LED

También se puede usar una LED que trae la MEGA incorporada.  El único cambio al código es que se usar el pin 13 ya que la LED que viene incorporada en la MEGA esta conectada internamente al pin 13 y de hecho trae incorporado también el resistor.  Ese proyecto se puede ver aquí:

https://youtu.be/vNQuAJ1LUYA

Es todo!  Parece insignificante pero la base es importante.  Porque?  Pues los dejo con estas ideas:

  • Esa LED podría ser un motor o un cerrojo o una valvula de flujo
  • En lugar de repetir el ciclo cada segundo, podríamos controlar el flujo en cada ciclo agregando una condición, ie: Si un botón esta oprimido, o un sensor ( de luz, sonido, calidad de aire, temperatura, huella digital, código ingresado etc) cumplen con las condiciones requeridas para enviar esa corriente.
  • O que pasa si, en lugar de solo enviar corriente, mandamos o leemos datos?  A internet?  A un celular?  A un BT, NFC etc…

Allí es donde se pone interesante.  Nos vemos en el proximo donde controlaremos la LED usando botones y potenciometros y aprenderemos a leer electricidad, no solo escribirla!