Python – Soloelectronicos.com

Cómo crear tu propia app de reloj con temperatura para Android (sin anuncios)

octubre 27, 2025octubre 28, 2025soloelectronicosDeja un comentario

A medida que pasa el tiempo vamos acumulando irremediablemente dispositivos totalmente o parcialmente funcionales como tabletas o smartphone que dejan de ser útiles por obsolescencia o simplemente porque hemos adquirido un dispositivo mas potente que supera en prestaciones a lo que ya teníamos. En esta encrucijada, sobre todo por el poco valor que puede tener un dispositivo antiguo, lo ideal es darle una segunda vida con otro uso como por ejemplo como cámara de seguridad, como panel de domòtica, etc. o mi favorita: !como reloj gigante!.

En efecto ¿estas cansado de las apps de reloj y temperatura llenas de publicidad o con versiones de pago? . La solución más simple es hacer tu propia app minimalista, gratuita y sin depender de servicios comerciales.
Y lo mejor: puedes hacerlo tú mismo, sin ser experto en Android.

Opción 1 — Kivy (Python): simple y rápida

Si ya trabajas con Python, esta es la forma más sencilla.
Kivy te permite crear interfaces gráficas multiplataforma y exportar tu app a Android con facilidad.

Qué necesitas

Un teléfono Android con Termux, o un PC con Linux/Windows.
Instalar las dependencias básicas:

bashpip install kivy buildozer

Con eso podrás compilar tu app a APK usando buildozer, directamente desde tu propio sistema.

Ejemplo mínimo: reloj + temperatura + pantalla encendida

from kivy.app import App
from kivy.uix.label import Label
from kivy.clock import Clock
from kivy.core.window import Window
import requests, datetime

Window.clearcolor = (0, 0, 0, 1)
Window.borderless = True
Window.show_cursor = False

class ClockApp(App):
    def build(self):
        self.label = Label(font_size='60sp', halign='center', valign='middle')
        Clock.schedule_interval(self.update, 60)
        self.update(0)
        return self.label

    def update(self, dt):
        now = datetime.datetime.now().strftime("%H:%M")
        temp = self.get_temperature()
        self.label.text = f"{now}\n{temp}°C"

    def get_temperature(self):
        try:
            url = "https://api.open-meteo.com/v1/forecast?latitude=40.4&longitude=-3.7&current_weather=true"
            data = requests.get(url, timeout=5).json()
            return int(data['current_weather']['temperature'])
        except:
            return "--"

if __name__ == '__main__':
    ClockApp().run()

Solo cambia las coordenadas latitude y longitude por tu ubicación.
Kivy mantiene la pantalla encendida automáticamente mientras la app esté activa.

Para generar el paquete instalable, compila con:

buildozer android debug

Obtendrás un APK listo para instalar.

Opción 2 — Android Studio (si prefieres Kotlin/Java)

También puedes hacerlo con Android Studio, en Kotlin, de forma muy sencilla:

class MainActivity : AppCompatActivity() {
    private lateinit var textView: TextView
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
        textView = TextView(this)
        textView.textSize = 64f
        textView.gravity = Gravity.CENTER
        setContentView(textView)
        update()
        Timer().scheduleAtFixedRate(object : TimerTask() {
            override fun run() { runOnUiThread { update() } }
        }, 0, 60000)
    }

    private fun update() {
        val time = SimpleDateFormat("HH:mm", Locale.getDefault()).format(Date())
        val temp = "--°C" // Aquí puedes añadir la API de Open-Meteo
        textView.text = "$time\n$temp"
    }
}

Con un par de líneas más puedes integrar la API gratuita de Open-Meteo para obtener la temperatura actual.

Resultado

Pantalla negra, texto blanco grande con hora + temperatura, sin apagado automático (KEEP_SCREEN_ON).
Sin publicidad, sin permisos extraños, sin coste.

Ideas para mejorar

Controlar el brillo máximo o modo nocturno.
Permitir configurar manualmente la ubicación.
Añadir fecha o iconos del clima.
Mostrar estado de batería o conexión Wi-Fi.

Conclusión:
Crear tu propia app de reloj con temperatura en Android no solo es posible, sino también una excelente forma de aprender desarrollo móvil sin depender de terceros.
Usar Kivy o Kotlin te permite mantener el control total: diseño limpio, sin anuncios y con funcionalidad útil para tu día a día.

Replicar en W11 un entorno python de Ubuntu

septiembre 7, 2025soloelectronicos1 comentario

En efecto es posible replicar en Windows 11 un entorno Python de Ubuntu como por ejemplo toda la Instalación de NILMTK o incluso NILMTK_CONTRIB

Para replicar tu instalación de NILMTK de Ubuntu en Windows 11 utilizando el Subsistema de Windows para Linux (WSL), sin Conda pero con Jupyter Notebook, y ya disponiendo del fichero requirements.txt y las carpetas nilmtk, nilm_metadata y nilmtk-contrib, puedes seguir estos pasos:

1. Preparar el Entorno WSL

Asegúrate de que tu distribución de Linux en WSL (por ejemplo, Ubuntu) tenga Python 3.6+ y pip instalados. NILMTK requiere Python 3.6 o superior.

Puedes verificar las versiones con python3 --version y pip3 --version.
Si es necesario, instálalos o actualízalos. Para Ubuntu en WSL, puedes usar:bashsudo apt update sudo apt install python3 python3-pip

2. Instalar Jupyter Notebook en WSL

Instala Jupyter Notebook usando pip en tu terminal WSL:

Ejecuta el comando:bashpip3 install jupyter Esto instalará Jupyter en tu espacio de usuario5.
Es posible que necesites añadir ~/.local/bin a tu variable de entorno PATH si los comandos de Jupyter no se encuentran. Edita tu archivo ~/.bashrc (o ~/.zshrc si usas Zsh) y añade la siguiente línea:bashexport PATH="$HOME/.local/bin:$PATH" Luego, aplica los cambios con source ~/.bashrc (o source ~/.zshrc)4.

3. Configurar las Carpetas y Dependencias de NILMTK

Copiar carpetas:
Transfiere tus carpetas nilmtk, nilm_metadata y nilmtk-contrib a un directorio de proyecto adecuado dentro del sistema de archivos de WSL (por ejemplo, ~/mi_proyecto_nilmtk/).

Instalar dependencias desde requirements.txt:
Navega en la terminal WSL al directorio donde se encuentra tu archivo requirements.txt (probablemente dentro de ~/mi_proyecto_nilmtk/). Luego, instala las dependencias:

bashcd ~/mi_proyecto_nilmtk
pip3 install -r requirements.txt

Si encuentras errores relacionados con la compilación de paquetes, es posible que necesites instalar herramientas de compilación. En Ubuntu WSL, esto se puede hacer con: sudo apt install build-essential.

Instalar nilm_metadata y nilmtk en modo desarrollo:
Esto permite que Python encuentre los paquetes en las carpetas que has copiado.

Para nilm_metadata (asumiendo que «nilmk-metadata» es un error tipográfico):bashcd ~/mi_proyecto_nilmtk/nilm_metadata # Ajusta la ruta si es diferente python3 setup.py develop
Para nilmtk:bashcd ~/mi_proyecto_nilmtk/nilmtk # Ajusta la ruta si es diferente python3 setup.py develop La instalación en modo desarrollo (develop) es útil para asegurar que los cambios en el código fuente se reflejen inmediatamente sin necesidad de reinstalar2.

Carpeta nilmtk-contrib:
El manejo de la carpeta nilmtk-contrib dependerá de su contenido. Si contiene paquetes Python adicionales con sus propios archivos setup.py, podrías necesitar instalarlos de manera similar. Si son datos o scripts, asegúrate de que estén en una ubicación accesible para tu proyecto.

4. Ejecutar Jupyter Notebook desde WSL

Navega en tu terminal WSL al directorio de tu proyecto (donde deseas que Jupyter Notebook acceda a los archivos y donde se guardarán los nuevos notebooks), por ejemplo, ~/mi_proyecto_nilmtk/.

Inicia Jupyter Notebook con el siguiente comando:bashjupyter notebook --no-browser La opción --no-browser evita que WSL intente abrir un navegador en el entorno Linux, lo cual generalmente no es deseado4 6.
La terminal mostrará un mensaje con una o más URLs, usualmente comenzando con http://localhost:8888/ e incluyendo un token de seguridad4 6. Copia una de estas URLs completas.
Abre un navegador web en Windows 11 (como Edge, Chrome o Firefox) y pega la URL copiada en la barra de direcciones.

5. Verificar la Instalación de NILMTK

Dentro de la interfaz de Jupyter Notebook en tu navegador:

Crea un nuevo notebook de Python 3.
En una celda de código, ejecuta:pythonimport nilmtk print(nilmtk.__version__)
Si no aparecen errores y se muestra la versión de NILMTK, la instalación se ha replicado correctamente y NILMTK está listo para usarse1.

Siguiendo estos pasos, deberías poder replicar tu entorno NILMTK en WSL en Windows 11, utilizando tus archivos y carpetas existentes y cumpliendo con tus requisitos de no usar Conda y sí Jupyter Notebook.

A veces a pesar de todo y seguir al pie de las letra los manuales no salen bien las cosas, A continuación algunos de los errores que podemos tener en la instalación:

Error `externally-managed-environment`

El error error: externally-managed-environment que estás viendo indica que tu sistema Linux (dentro de WSL) gestiona los paquetes de Python a través de su propio administrador de paquetes (como apt en Ubuntu/Debian) para evitar conflictos y asegurar la estabilidad del sistema 1 4 5. Por lo tanto, pip no te permite instalar paquetes globalmente por defecto.

La forma recomendada y más segura de proceder es crear un entorno virtual. Esto aislará tu proyecto de NILMTK y sus dependencias, incluyendo Jupyter, del Python del sistema 4 5.

Aquí te explico cómo continuar:

METODO 1

1. Crear y Activar un Entorno Virtual en WSL

En tu terminal WSL, antes de intentar instalar Jupyter o cualquier otro paquete con pip, crea un entorno virtual. Es una buena práctica hacerlo dentro de tu directorio de proyecto.

Navega a tu directorio de proyecto (donde tienes las carpetas nilmtk, nilm_metadata, nilmtk-contrib y tu requirements.txt):bashcd ~/mi_proyecto_nilmtk # O la ruta donde hayas puesto tus archivos
Crea el entorno virtual (puedes llamarlo venv_nilmtk o como prefieras):bashpython3 -m venv venv_nilmtk Es posible que necesites instalar primero el paquete python3-venv si no está disponible: sudo apt install python3-venv 5.
Activa el entorno virtual:bashsource venv_nilmtk/bin/activate Una vez activado, tu prompt de la terminal debería cambiar para indicar que estás dentro del entorno virtual (por ejemplo, (venv_nilmtk) canjayar@carlosrn:...$).

2. Instalar Jupyter y tus Dependencias Dentro del Entorno Virtual

Ahora que el entorno virtual está activo, pip (o python -m pip) instalará los paquetes dentro de este entorno aislado, sin afectar al sistema global.

Instala Jupyter Notebook:bashpip install jupyter (Dentro de un entorno virtual activado, generalmente pip se refiere al pip del entorno, que corresponde a la versión de Python con la que se creó el entorno).
Instala las dependencias de NILMTK desde tu archivo requirements.txt:bashpip install -r requirements.txt
Instala nilm_metadata y nilmtk en modo desarrollo (como se indicó anteriormente, pero ahora dentro del entorno virtual):bashcd nilm_metadata # Ajusta la ruta si es diferente python setup.py develop cd ../nilmtk # Ajusta la ruta si es diferente python setup.py develop cd .. # Vuelve al directorio raíz de tu proyecto

3. Ejecutar Jupyter Notebook

Con el entorno virtual aún activado:

Inicia Jupyter Notebook:bashjupyter notebook --no-browser
Copia la URL proporcionada (incluyendo el token) y pégala en tu navegador de Windows 11.

Otras Opciones (Menos Recomendadas)

Usar --break-system-packages: Podrías forzar la instalación global con pip3 install jupyter --break-system-packages 2 4. Sin embargo, esto no es recomendable ya que puede causar problemas con los paquetes gestionados por el sistema operativo y potencialmente romper tu instalación de Python o WSL 1 5.
Instalar con apt: Podrías intentar sudo apt install python3-notebook (el nombre del paquete puede variar). Esto instalaría la versión de Jupyter de los repositorios de tu distribución, que podría no ser la más reciente o la que necesitas. Generalmente, para desarrollo Python, se prefiere pip dentro de un entorno virtual para tener más control sobre las versiones de los paquetes.

Error de dependencias

El error en la instalación de dependencias, específicamente con nilm-metadata @ file:///home/user/nilm_metadata, se debe a que pip está intentando encontrar el paquete nilm-metadata en la ruta del sistema de archivos WSL (/home/user/nilm_metadata), pero esa ruta no es válida desde la perspectiva de Windows (donde la ruta correcta sería C:\Users\user\mi_proyecto_nilmtk).

Para solucionar esto, tienes que modificar la referencia a nilm-metadata en tu archivo requirements.txt para que pip pueda encontrar el paquete correctamente. Hay dos opciones principales:

Opción 1: Modificar `requirements.txt` para usar la ruta WSL correcta (recomendado)

Edita requirements.txt dentro de WSL. Abre el archivo requirements.txt con un editor de texto (como nano o vim) dentro de tu entorno WSL.
Encuentra la línea que menciona nilm-metadata. Debería ser algo como:textnilm-metadata @ file:///home/carlos/nilm_metadata
Cambia la ruta a la ruta WSL correcta. Si tu directorio de proyecto mi_proyecto_nilmtk está directamente dentro de tu directorio de inicio en WSL, la ruta podría ser correcta. Sin embargo, si has movido la carpeta nilm_metadata a otro lugar dentro de WSL, asegúrate de que la ruta refleje la ubicación correcta dentro del sistema de archivos de WSL.Por ejemplo, si la estructura de directorios en WSL es:text/home/carlos/mi_proyecto_nilmtk/nilm_metadata Entonces la línea en requirements.txt debería ser:textnilm-metadata @ file:///home/carlos/mi_proyecto_nilmtk/nilm_metadata
Guarda los cambios en requirements.txt.
Reintenta la instalación:bashpip install -r requirements.txt

Opción 2: Eliminar la referencia y usar `pip install -e .` en la carpeta `nilm_metadata`

Esta opción es útil si planeas desarrollar activamente nilm_metadata y quieres que los cambios se reflejen inmediatamente.

Elimina la línea de nilm-metadata de requirements.txt.
Instala nilm_metadata en modo editable:bashcd nilm_metadata pip install -e . cd .. # Para volver al directorio principal de tu proyecto

Consideraciones Adicionales

Entornos Virtuales: Asegúrate de que tu entorno virtual esté activado cuando realices estos cambios y reinstales las dependencias.
Permisos: Los permisos de archivo dentro de WSL pueden ser a veces problemáticos, especialmente cuando se interactúa con archivos en el sistema de archivos de Windows. Si encuentras errores de permiso, verifica que tienes los permisos adecuados para leer y escribir en los directorios y archivos relevantes desde dentro de WSL. 3.
Rutas absolutas vs. relativas: En general, es mejor usar rutas relativas dentro de requirements.txt si es posible, para que el archivo sea más portátil. Sin embargo, con instalaciones locales como esta, a veces las rutas absolutas son más directas.
WSL2 file system: WSL2 utiliza un sistema de archivos virtualizado. Asegúrate de que las rutas sean correctas dentro de este sistema.

Al seguir estos pasos y asegurarte de que las rutas en tu requirements.txt son correctas para el sistema de archivos WSL, deberías poder resolver el error y continuar con la instalación de NILMTK.