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.

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:

Computadora (mac)
Arduino MEGA u otra.
LED
Breadboard
Arduino IDE (https://www.arduino.cc/en/Main/Software)
Potenciómetro
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

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

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:

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.

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:

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!

Santiapps – Arduino, Raspberry Pi, Python, Internet Of Things, IoT, iOS, Android

Posts

Saving HealthKit Data & Closures

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

Tutorial Pots & Botones

Air Quality Monitor: Arduino Honduras