La tecnología wearable ha evolucionado rápidamente, convirtiéndose en una extensión del cuerpo humano. Desde relojes inteligentes hasta gafas de realidad aumentada, estos dispositivos no solo nos acompañan, sino que también recopilan y analizan datos vitales en tiempo real.

Pero ¿qué se necesita para desarrollar aplicaciones efectivas y funcionales en este entorno? Este post te guía por las principales herramientas para el desarrollo de soluciones en wearables, complementado con actividades que refuerzan tu comprensión de forma lúdica y reflexiva.

Herramientas esenciales para el desarrollo en wearables

Al trabajar con dispositivos portables, es importante elegir las herramientas adecuadas según el ecosistema (Android, Apple, o plataformas independientes). Aquí algunas de las más importantes:

• Android Studio con Wear OS
  IDE oficial de Google para desarrollar apps en relojes inteligentes con Android.
• Xcode con watchOS
  Para desarrollo en dispositivos Apple Watch, incluye simuladores y herramientas nativas.
• Flutter + plugins para wearables
  Framework multiplataforma con soporte creciente para wearables, ideal para prototipos rápidos.
• Tizen Studio
  Usado principalmente para relojes Samsung, basado en HTML5/C++.
• Fit SDK (Garmin)
  Kit para integrar funciones específicas de dispositivos Garmin.
• Bluetooth Low Energy (BLE) APIs
  Herramientas que permiten comunicación eficiente entre el wearable y otros dispositivos.
• Sensor APIs
  Acceso a datos biométricos como ritmo cardíaco, pasos, movimiento y oxígeno en sangre.

Actividades

Aprendizaje

Caso de estudio: En la piel del código: cuando crear para wearables fue más que solo desarrollar

Después de leer el caso, responde a estas preguntas de reflexión:

Preguntas de reflexión (con respuestas guía)

1. ¿Qué motivó a Santiago a desarrollar una app personalizada?
2. ¿Qué limitaciones encontró con los dispositivos existentes?
3. ¿Por qué abandonó Flutter a pesar de su facilidad práctica?
4. ¿Qué herramientas utilizó en el desarrollo?
5. ¿Cuál fue el mayor aprendizaje de Santiago?
6. ¿Qué desafío ético enfrentó implícitamente?
7. ¿Cómo puede el desarrollo para wearables equilibrar personalización y escalabilidad?
8. ¿Qué desafíos éticos implica crear tecnología que monitorea la salud en tiempo real?
9. ¿Qué rol juegan las emociones del desarrollador cuando el proyecto es personal?
10. ¿Hasta qué punto es necesario entender al usuario más allá de sus datos biométricos?
11. ¿Qué herramientas actuales permiten una mejor integración entre hardware y experiencia de usuario en wearables?
12. ¿Cómo influye el diseño de interfaces mínimas en la efectividad de las aplicaciones para dispositivos portables?

Después de contestarlas puedes escribir tus respuestas en los comentarios o compartirlas en clase.

Reforzamiento

Sopa de letras: Pulsa aquí para acceder a la sopa de letras

Crucigrama: Pulsa aquí para acceder al crucigrama.

Exploratorias

Ahora es turno de usar tus habilidades de invesitigación para realizar los siguiente:

1.  Genera una investigación a profundidad sobre el tema herramientas de desarrollo y emuladores aplicable a la creación de interfaces en wearables.
2. Después crea una tabla donde se muestre las ventajas, desventajas, sistema operativo en el que se encuentra disponible, si es open sources y una columna sobre tus comentarios.

El desarrollo para wearables va más allá de lo técnico: se trata de crear tecnología con sentido humano, que se integra a la vida de las personas. Aprender a utilizar las herramientas adecuadas es el primer paso para crear soluciones que no solo funcionen, sino que también impacten.

La entrada Herramientas para el desarrollo en Wearables se publicó primero en Frexus.

Todo empezó

En una ocasión que tocaba realizar unas modificaciones a la un segmento de código de un proyecto en particular, resulta que el proyecto para ejecutarse debe de comunicarse con un API y para ello hay que crear una instancia de comunicación, que permita hacer uso de ella y demás.

El detalle

Fue que todo estaba bien pero al hacer uso de una de los métodos, en ocaciones no funcionaba bien y en otros sí sin problemas. Y El código hacía lo que se requería.

Pero al comentar la situación con el equipo, y de manera razonable el problema parecía que se centraba más en que el ambiente virtual no era el mismo al momento en que se ejecutaba, Pues virtualmente la versión de la librería era el adecuado, las pruebas salían bien. Incluso al indicarle al IDE al hacerle las pruebas de comunicación marcaba error. Y por eso se consideraba justamente que el problema radicaba en indicar el ambiente virtual tomar.

Entonces se opta por quitar todos los ambientes virtuales y dejar solo uno, el IDE toma ese ambiente y pum aún sigue marcando el mismo error, de no poder conectar con el API, y si llegaba a conectar marcaba que ese atributo no existe dentro de la API. Se toma la iniciativa de ejecutar el código fuente en otro equipo, con otro sistema operativo, creyendo que pudiera ser alguna cuestión de arquitectura o algo así.

El detalle es que al crear el ambiente en otro equipo, con otro sistema operativo, se realiza la prueba de conexión y funcionaba, se verifica la existencia del atributo y existe. Entonces se valida la versión de la librería y era la misma, se comprueba el origen y es el mismo. Y entonces el problema ¿dónde radicaba? era la gran cuestión.

La solución

Llego cuando al comprobar los mismos datos del otro equipo en la maquina donde se estaba trabajando, ver que coincidía y que aún marcaba los mismos detalles, se hace la prueba de ejecutar todo el fuente en el otro equipo resultando que también marcaba el mismo error.

Entonces se empieza a hacer un debug sobre cada línea y se va dando cuenta que las variables usadas para hacer una instancia de la API, estaban mal. Y a simple vista se veía bien las instancia y el llamado a la misma. Pero tenían nombre que no hacía referencia mucho a ellas.

La moraleja

Es que siempre es importante crear las variables que se usen haciendo referencia a lo que contendrá, ya que en la actualidad es fácil declarar una variable que sea solo una letra y que sea reasignada indefinidas veces durante el transcurso del programa perdiendo sus valores originales. Afectando a otras partes del programa. O normalizarlas. para evitar esos detalles.

La entrada Las variables también hacen travesuras se publicó primero en Frexus.

Existirá momentos en los que se requiera conocer mas información de un dataframe que permita decir cuántas columnas de tipo entero, fecha, decimal existe en él. Para ello se hace uso de la función info que trae pandas; la sintaxis para su uso es la que se muestra a continuación:

df.info()

¿Cómo se usa?

Bien, mantener el siguiente supuesto: “el csv pruebas” se requiere saber los tipos de columnas que tiene.

En la imagen 1 se puede apreciar que aparece en la terminal el número de indice, se observa una columna con el nombre column donde se indica los nombre de cada una de las columnas que tiene el df (dataframe) y una tercera columna donde se muestra los tipos de datos al que pertenece cada columna del df y finalmente muestra un resumen donde un resumen que indica cuantos columnas de que tipo de dato hay y que espacio esta ocupando en la memoria el df.

El código de ejemplo se encuentra aca en el git

La entrada Pandas y la info del dataframe se publicó primero en Frexus.

df.head(numero_registro)

La sintaxis para mostrar las últimas filas es la que se muestra a continuación:

df.tail(numero_registro)

Usando head y tails

Teniendo un dataframe donde solo se quieren visualizar los primeros cinco registros y los últimas cinco filas. Observe que en la imagen 1, se muestra a la derecha una hoja de calculo 25 registros que se cargaron en el dataframe, pero que al ejecutar la linea

Muestra los primeros cinco registros que coinciden con los que se muestra en la hoja de calculo de la izquierda

df.head(5)

Ahora para mostrar los últimos cinco registros del dataframe se debe de ejecutar lo siguiente:

df.tail(5)

Si se quisiera mostrar los primeros 10 o los últimos 15 solo habrá que cambiar el cinco por 10 y 15 respectivamente, sin olvidar que head es para los primeros y tail para los últimos.

El código fuente de este ejercicio lo encuentras en el git

La entrada Pandas y las primeras – últimos registros se publicó primero en Frexus.

df['nombre_columna_nueva'] = df['nombre_columna_copiar']

Siguiendo con el ejemplo, se ha renombrado una columna registrados a register. Bien ahora se creara una columna nueva que contenga los valores de registrados y tendrá el nombre de Registrados. El código sería algo como lo que se muestra a continuación:

import pandas as pd

# cargando fichero
df = pd.read_csv('../prueba.csv', sep=',')
# renombrando columna
df.rename(columns={'registrados': 'register'}, inplace=True)
# creando nueva columna
df['Registrados'] = df['register']

En la imagen uno se puede apreciar que del lado derecho se tiene dos recuadros el que se encuentra arriba muestra el dataframe renombrado, y el que esta abajo muestra el mismo dataframe con una columna creada con el nombre Registrados. Como se puede apreciar en las líneas de código (a la izquierda de la imagen uno) una simple línea permite crear una nueva columna.

El código fuente de este ejercicio lo encuentras en el git

La entrada Pandas y la creación de columnas nuevas se publicó primero en Frexus.

df = pd.read_csv(nombre_fichero)   

Bajo el supuesto de que se quiera leer un archivo con el nombre “pruebas.csv” usando pandas se haría de la siguiente forma:

import pandas as pd
df = pd.read_csv("pruebas.csv")

Con esas dos líneas se tendría el contenido del csv en la variable df. Si al momento de crear el archivo csv se le coloco el separador de la coma (,) o el puto y coma (;), quedaría algo como:

import pandas as pd

df = pd.read_csv('pruebas.csv, sep=',')

df_2 = pd.read_csv('prueba.csv, sep=';')

En la imagen uno se puede observar el uso de una linea donde se incluye el nombre del archivo (hoja de calculo de la izquierda, en formato csv) y el valor de la variable df (a la derecha, a quien se le pasa el contenido del fichero csv) se tiene los mismos datos ahora ya con los valores en la variable df se puede hacer un buen de cosas.

El código fuente de este ejercicio lo encuentras en el git

La entrada Leyendo archivos con pandas en python se publicó primero en Frexus.

Requerimientos

Antes de iniciar se debe de tener instalado lo siguiente:

• Anaconda
• actualizar anaconda (conda update –all)
• instalar qt (conda install qt)
• instalar pyqt (conda install pyqt)

El designer

Para iniciar a diseñar la interfaz se hace uso del comando designer aparecerá una ventana similar a la que se muestra en la imagen 1.

1. Si se va a diseñar una nueva ventana se hace clic en en el botón crear (vea botón azul de la imagen 1)

2. Una vez que se realizo el paso 2. ya se puede proceder a diseñar la interfaz como uno desee, arrastrando etiquetas, botones y lo que se vaya a requerir en el lugar que se quiera.

3. Una vez que se ha procedido a colocar los objetos (etiquetas, botones, cuadro de textos y demás) se guarda la interfaz y se debe de observar que su extención es *.ui. ahora solo hay que convertir esa interfaz a python para ello se hace uso del siguiente comando:

pyuic5 -x archivo_guardado_designer.ui -o fichero_designer_python.py
# en el supuesto de que el archivo de interfaz se haya llamado ventana.ui y se convertirá al fichero ventana_ui.py quedaría
pyuic5 -x ventana.ui -o ventana_ui.py

4. Ahora solo hay que importar el archivo convertido / transformado en el fichero de funciones de python. quedaría algo como:

from ventana_ui import * 

Ya ventana_ui.py contiene todos los elementos que se requiere, ahora solo es momento de crear las funciones para los botones y demás.

Conclusiones

Lo que me ha agradado de qt es que tiene un diseñador de interfaz que permite ahorrar un buen de tiempo y generación de código. Claro que si quieres un elemento nuevo o si se quiere hacer más grande una etiqueta hay que entrar al designer editar el componente y actualizar el archivo (realizar la conversión o transformación del archivo ui a py). De ahí en fuera queda ideal para la creación de aplicaciones de escritorio.

La entrada Interfaz Gráfica con python y QT se publicó primero en Frexus.

1. Cree un programa que le pida su nombre a usuario y lo salude por su nombre

var nom;
process.stdout.write("¿cuál es tu nombre? \n ");
process.stdin.on('data', function(data){
    nom = data.toString().trim();
    process.stdout.write("hola " + nom +", bienvenido a nodejs \n");
    process.exit();
});

El código fuente de este ejercicio se encuentra en el git

2. Cree un programa que solicite el radio de un circulo y entregue como salida el perímetro y el área.

var rad;
var peri;
var area;
process.stdout.write("Introdusca el valor del radio: \n");
process.stdin.on('data', function(data){
    rad = data.toString().trim();
    peri = 2 * 3.1416 * rad;
    area = rad * rad
    process.stdout.write("El perimetro es: "+peri+".\nEl área es: "+area+".\n");
    process.exit();
});

El código fuente de este ejercicio están en el git

3. cree un programa que permita calcular el promedio de cuatro calificaciones ingresadas por el usuario

4. Cree un programa que convierta de centímetros a pulgadas. Una pulgada es igual a 2.54 centímetros.

var nc;
const cm = 2.54;
var pl;
process.stdout.write("Introduce el número de centímetros\n");
process.stdin.on('data', function(data){
	nc = data.toString().trim();
    pl = nc / cm;
    process.stdout.write("El número de pulgada es: "+pl);
    process.exit();
});

El código fuente de la solución de este ejercicio se puede ver el git.

5. Cree un programa que reciba como entrada las longitudes de los dos catetos aa y bb de un triángulo rectángulo, y que entregue como salida el largo de la hipotenusa cc del triángulo, dado por el teorema de Pitágoras.

6. Cree un programa que pregunte al usuario la hora actual t del reloj y un número entero de horas h, que indique qué hora marcará el reloj dentro de h horas.

7. Cree un programa que solicite al usuario su edad y el programa le muestre las décadas, lustros, años, meses, semana, días, horas y minutos vividos.

var edad;
var decada, lustro, anio, mes, semana, dia, horas, minuto;
process.stdout.write("Introduce su edad\n");
process.stdin.on('data', function(data){
	edad = data.toString().trim();
    decada = edad / 10;
    lustro = edad / 5;
    anio = edad;
    mes = anio * 12;
    semana = anio * 52;
    dias = anio * 365;
    horas = dias * 24;
    minuto = horas * 60;
    process.stdout.write("Cuenta con: "+decada+' decadas, '+lustro+' lustros,'+anio+' años, '+mes+' meses, '+dias+' dias, '+horas+' horas, '+minuto+' minutos vividos.');
    process.exit();
});

El código fuente lo encuentras aquí

8. Cree un programa que solicite al usuario el valor de un lado de un cuadrado, calcule el área y el perímetro de un cuadrado.

var lado;
var area;
process.stdout.write("Introduce el valor de un lado\n");
process.stdin.on('data', function(data){
	lado = data.toString().trim();
    area = lado * lado;
    process.stdout.write("El valor del area es: "+area);
    process.exit();
});

9. Cree un programa que solicite al usuario la base de un triángulo y su altura, calcule el área de un triángulo.

10. Cree un programa que permita calcular el promedio de los siguientes número: 19, 17, 21, 09, 12, 07.

prom = (19 + 17 + 21 + 9 + 12 + 7) / 6;
console.log("El promedio es: "+ prom);

El código lo encuentras aquí

11. Cree un programa que permita convertir kilogramos a libras (1 kilogramo = 2.2 libras).

var lib;
process.stdout.write("Escribe el valor en kilos a convertir \n");
process.stdin.on('data', function(data){
	lib = data.toString().trim();
	lib = lib * 2.2;
	console.log("El valor en libras es: "+lib);
	process.exit();
})

El código fuente lo encuentras aquí

12. Elabore un programa que permita recibir dos números y mostrar la suma, resta, multiplicación y división de esos dos números.

13. Un obrero trabaja 8 horas diarias por quincena y le pagan 50 pesos la hora y de su salario tiene una compensación del 2% y un descuento del 1.5% del IMSS Y 1.2% del ISPT. Escriba un programa que permita calcular el salario neto del trabajador.

var hr;
process.stdout.write("¿Cuántas horas trabajo el obrero? 80hr = 15a \n");
process.stdin.on('data', function(data){
	hr = data.toString().trim();
	sal = hr * 50;
	com = sal * 0.02;
	salcom = sal + com;
	ims = salcom * 0.015;
	ispt = salcom * 0.012;
	salnet = salcom - (ims + ispt);
	console.log("Pago de horas trabajadas: "+sal);
	console.log("+")
	console.log("Compensación: "+ com);
	console.log("_________________________________");
	console.log("Salario y Compensación: "+salcom);
	console.log("-")
	console.log("Descuento IMSS: "+ims);
	console.log("Descuento ISPT: "+ispt);
	console.log("_________________________________")
	console.log("Salario neto: "+salnet);
	process.exit();
})

Puede descargar el código fuente aquí

14. Cree un programa que permita convertir Convertir X pies a M metros. P=0.3048.

var pies;
process.stdout.write("¿Cuántos pies hay que convertir? \n");
process.stdin.on('data', function(data){
	pies = data.toString().trim();
	mts = pies / 3.2808;
	console.log("La cantidad de metros es: "+mts);
	process.exit();
})

Puede mirar el código aquí

15. Cree un programa que permita convertir N pulgadas a M metros. 1 Pulgada = 2.54 cm/100 = 0.0254.

var plg;
console.log("¿Cuántos pies hay que convertir?");
process.stdin.on('data', function(data){
	plg = data.toString().trim();
	mts = plg / 39.370;
	console.log("La cantidad de metros es: "+mts);
	process.exit();
})

Descarga el fuente desde aquí

16. Cree un programa que permita convertir X pies a N pulgadas. 1 pie = a 12 pulgadas.

var pies;
console.log("¿Cuántos pies hay que convertir?");
process.stdin.on('data', function(data){
	pies = data.toString().trim();
	plg = pies * 12.000;
	console.log("Las pulgadas son: "+plg);
	process.exit();
})

Descarga el fuente desde aquí

17. Cree un programa que permita convertir G galones a L litros.

var gln;
console.log("¿Cuántos galones hay que convertir?");
process.stdin.on('data', function(data){
	gln = data.toString().trim();
	lt = gln / 0.21997;
	console.log("El total de litros es: "+lt);
	process.exit();
})

Puedes descargar el fuente desde aquí

18. Cree un programa que permita convertir grados centígrados a grados Fahrenheit. (0 °C × 9/5) + 32 = 32 °F.

var gc;
console.log("¿Cuántos grados centigrados hay que convertir?");
process.stdin.on('data', function(data){
	gc = data.toString().trim();
	gf = (gc * 1.8000) + 32.00;
	console.log("La conversión a Fahrenheit es: "+gf);
	process.exit();
})

Puede descargar el código fuente aquí

19. Cree un programa que imprima sus iniciales en mayúsculas de imprenta, de manera que apunten hacia la parte inferior de la página (acostadas). Construya cada mayúscula de imprenta con la letra que ésta representa.

console.log("aaaaaaaaaaaaaaaaaa");
console.log("         a       a");
console.log("         a       a");
console.log("         a       a");
console.log("         a       a");
console.log("aaaaaaaaaaaaaaaaaa");
console.log("jjjjjjjjj");
console.log("j");
console.log("j");
console.log("j");
console.log("j");
console.log("jjjjjjjjjjjjjjjjjj");

Puedes descargar el código fuente aquí

Han faltado la solución de unos ejercicios donde se requiere solicitar más dos valores al usuario. aún no termino de encontrar una solución que permita hacerlo y que me agrade, sin que se tenga que hacer uso del html.

La entrada Ejercicios resueltos en NodeJs se publicó primero en Frexus.

Debido a que Nodejs no es un lenguaje de programación, pero como le da soporte (por decirlo de esa manera) a JavaScript, los tipos de datos que se puede usar son todos los que admite JavaScript. Entre los que se encuentran:

Se tiene de dos tipos primitivos controlados por el operador typeof cómo los que se muestran ahora:

• Undefined: Una variable a la que no se le ha asignado un valor, éste se encuentra en undifined.
• Boolean: Representa una entidad lógica y puede tener dos valores: true y false.
• Number: contando con dos tipos de datos numéricos
  • Number: valor en formato binario de 64 bits doble precisión van desde -253 a 1 y desde 253 a 1. Además de representar los decimales, tiene tres valores simbólicos +inifinity, -infinity y NaN (“not a Number”, no es un número). Para
  • BitInt: se puede representar números enteros con precisión arbitraria, se puede almacenar y operar de forma segura en números enteros grandes incluso más allá del límite seguro de enteros para Number. Éste se crea agregando una “n” (ene) al final de un número entero o llamado constructor.
• String: Utilizado para representar datos textuales. Conjunto de elemento sde valores enteros sin signos de 16 bits.
• Symbol: Es un valor primitivo único e inmutable y se puede utilizar como clave de una propiedad de objetos.

• Null: Tipo de dato primitivo que si no se hereda, se muestra null
• Objeto: Tipo estructural especial que no es de datos pero para cualquier instancia de objeto construido que también se utiliza como estructura de datos.
• Function: una estructura sin datos, aunque también responde al operador typeof.

La entrada tipos de datos en NodeJs se publicó primero en Frexus.

var nombre_variable = valor ; 

Sin embargo al usar nodejs es común que se use la palabra reservada let para una declaración de variable su uso queda como se muestra a continaución:

let NombreVariable = valor;

Recomendaciones para el nombre de variables

• No debe de iniciar con un dígito, o carácter especial.
• Solo se puede separar el nombre de una variable por el carácter guión bajo (_).
• No se debe de usar los espacios en blanco entre nombre de variables.

La entrada Las Variables en NodeJS se publicó primero en Frexus.