En el tutorial anterior , aprendimos sobre el widget de ventana en Tkinter y diseñamos una ventana GUI principal en blanco (que no es hija de ninguna otra ventana en la aplicación GUI). Las ventanas secundarias sirven como contenedores para otros widgets.
No tiene sentido tener ventanas en blanco, por lo que deben incluirse otros widgets en el widget de ventana para facilitar la interacción del usuario. Los widgets contenidos en un widget de ventana son hijos de esa ventana.
Widgets Tk
Tk es un conjunto de herramientas de interfaz de usuario multiplataforma. Se puede utilizar para diseñar interfaces gráficas de usuario para sistemas X11, Microsoft Windows y Mac OS X. Actualmente, los lenguajes de programación que utilizan Tk como conjunto de herramientas GUI incluyen Python, Ruby, Pearl y Tcl.
Una GUI consta de varios widgets organizados en un contenedor de widgets. Los widgets pueden verse como elementos gráficos que proporcionan un tipo específico de interacción y funcionalidad en la interfaz de usuario. El widget contenedor de nivel superior es siempre una ventana.
Tk proporciona varios widgets para interfaces de tipo formulario para completar, así como menús, ventanas, cuadros de diálogo estándar e imágenes. También admite colores, fuentes, estilos y temas para interfaces de usuario.
Los widgets que se incluyeron originalmente en el paquete se denominan widgets clásicos y están empaquetados como el módulo Tkinter. Tk 8.5 agregó recientemente un nuevo conjunto de widgets temáticos, que están disponibles como paquete ttk. Sin embargo, el paquete ttk debe importarse por separado si está interesado en utilizar estos nuevos widgets con Tkinter.
Los widgets se incluyen en una aplicación GUI como objetos de clase, cada uno con su propia apariencia y funcionalidad. Esto significa que todos los widgets son subclases de Tkinter/ttk y es necesario crear instancias de objetos de estas clases para incluir los widgets en nuestra GUI.
Tkinter no tiene un editor WYSIWYG. Entonces, para crear cada widget, necesitaremos escribir código para él y administrar los widgets dentro de ese código. La gestión de cualquier widget normalmente implica tres operaciones:
1. Configurar la apariencia del widget
2. Configurar el diseño del widget
3. Agregar funcionalidad o comportamiento al widget
En Tkinter, la apariencia de un widget se puede establecer definiendo las opciones de configuración disponibles para el mismo. En el código, estas configuraciones se determinan definiendo los atributos disponibles para este objeto de clase de widget.
Definir el diseño del widget significa dónde y cómo debe aparecer el widget en el contenedor del widget (es decir, en la ventana o marco). Tkinter proporciona tres tipos de gestión de diseño (geometría): posicionamiento absoluto, diseño de paquete y diseño de cuadrícula.
Los widgets se pueden organizar como uno de estos tipos llamando a los métodos lugar, paquete o cuadrícula. Las opciones de configuración de un widget se pueden configurar en cualquier momento antes o después de llamar a un método de gestión de diseño en el widget. Sin embargo, hasta que se llame a uno de los métodos de administración de diseño (local, paquete o cuadrícula) para un objeto de widget, no aparecerá en el widget contenedor.
Las aplicaciones GUI siempre están controladas por eventos y cada widget tiene su propio conjunto de eventos disponibles. Estos eventos se desencadenan por la interacción del usuario. Por ejemplo, el usuario puede desencadenar un evento y se ejecutará un bloque de código en respuesta.
El proceso de escribir el comportamiento del código para un evento (widget) se denomina enlace de evento. El bloque de código ejecutado en respuesta a un evento (widget) se denomina controlador de eventos. El controlador de eventos debe ser invocable para que pueda ser una función o un atributo/método invocable de un objeto de clase.
Agregar funcionalidad o comportamiento de código a un widget en Tkinter es lo mismo que vincular eventos para ese widget. La vinculación de eventos a un widget se puede realizar asignando un elemento invocable (función o método de clase) al atributo de comando (si está disponible para ese widget) o utilizando el método de vinculación.
El paquete Tkinter con ttk (además de ventanas, cuadros de diálogo estándar, menús e imágenes) ofrece estos widgets básicos:
- Marco
- Etiqueta
- Botón
- Botón verificar
- boton de radio
- Prohibido
- caja combo
- Cuadro de lista
- barra de desplazamiento
- Agarre de tamaño
- Texto
- Barra de progreso
- Escala
- Caja giratoria
- Separador
- Marco de etiqueta
- ventana panorámica
- Diario
- Pantalla
- Vista de árbol
Marco, Etiqueta, Botón, Botón de verificación, Botón de radio, Entrada y Cuadro combinado son widgets para el tipo de interfaz de llenado de formulario. Listbox, Scrollbar, Sizegrip, Text, Progressbar, Scale y Spinbox son widgets adicionales para propósitos específicos. Frame, Labelframe, Panedwindow y Notebook sirven como widgets contenedores dentro de los widgets de ventana.
El widget Treeview muestra una lista de elementos dispuestos en orden jerárquico. El widget de lienzo es un potente widget que se puede utilizar para dibujar, diagramar o crear otros widgets complejos. El Separador es un widget de presentación que se puede utilizar para separar dos grupos diferentes de widgets.
De los widgets mencionados anteriormente, Combobox, Notebook, Separator, Progressbar, Sizegrip y Treeview son widgets nuevos que solo vienen con el paquete ttk.
A menudo usaremos los widgets Marco, Etiqueta, Cuadro combinado, Entrada, Texto, Botón de verificación, Botón de radio y Botón en la GUI para nuestras recetas de Raspberry Pi. Estos widgets se describen a continuación:
Marco: sirve como widget contenedor dentro de los widgets de ventana. Son contenedores rectangulares ideales para agrupar y ordenar otros widgets. Un marco se utiliza como clase principal para otros objetos de widget (clase) contenidos en él.
Los marcos se ven así:
Se puede crear un marco creando una instancia de un objeto de marco. Se puede crear una instancia del objeto frame utilizando el método Frame de tkinter o la clase ttk. La definición de un objeto de marco tiene esta sintaxis:
var = Marco(padre, (opciones de configuración,….)
Este es un ejemplo válido de creación de un tablero:
LED_def = Frame(root) # root es el nombre de la ventana principal:
Un marco en sí es un widget contenedor que sólo se puede crear dentro de un widget de ventana. El padre del objeto de marco puede ser la ventana principal o cualquier ventana secundaria. El "padre" es un argumento obligatorio que debe pasarse a una definición de marco. Las opciones de configuración, que cambian la apariencia del widget, son argumentos opcionales.
Un objeto de marco tiene estas opciones de configuración:
Los colores (como bg) en Tkinter se asignan como cadenas, que pueden ser valores hexadecimales para colores (como “#fff”, #fdfdfd, etc.) o nombres de colores (como “rojo”, “azul”, “verde” etc.).
Cabe señalar que todas las dimensiones (ancho de borde, relleno, etc.) definidas como un número entero tomarán un valor de píxel. A las dimensiones se les puede asignar una unidad añadiendo al valor el sufijo de los siguientes indicadores:
De forma predeterminada, los marcos no tienen bordes. Si se le da un valor a un atributo “bd” y a un atributo “relieve” (que no sea plano), el marco tendrá un borde con ese ancho y estilo. El atributo de relieve determina el estilo del borde.
Los estilos de relieve admitidos en Tkinter son plano, elevado, hundido, ranurado y cresta. Si el marco tiene un estilo de relieve asignado como "plano", su borde no se mostrará.
Los cursores de mouse admitidos en Tkinter incluyen: flecha, círculo, reloj, cruz, dotbox, interruptor, flor, corazón, hombre, mouse, pirata, además, transporte, escala, araña, lata de aerosol, estrella, objetivo, cruz, caminar y reloj. El cursor predeterminado es "flecha".
Las opciones de configuración del marco se pueden definir como argumentos de pares clave-valor en la definición del marco o se pueden establecer explícitamente. Aquí hay dos ejemplos válidos de configuración de opciones de configuración para un marco:
LED_def = Marco (raíz, padx = 25, pady = 10)
LED_def.grid
o
LED_def = Marco (raíz)
LED_def.grid
LED_def(“padx”)= 25
LED_def(“pady”)= 10
Los marcos sirven sólo como widgets contenedores para otros widgets básicos y no implican enlace de eventos.
Etiqueta: sirve como contenedor para texto e imágenes. El texto dentro de una etiqueta se puede actualizar o cambiar. Generalmente, las etiquetas se utilizan para indicar el propósito de otros widgets en la interfaz.
Las etiquetas se ven así:
Se puede crear una etiqueta creando una instancia de un objeto de etiqueta. Se puede crear una instancia de un objeto de etiqueta utilizando el método Label de Tkinter o la clase ttk. La definición de un objeto de etiqueta tiene esta sintaxis:
var = Etiqueta(padre, (opciones de configuración,….)
A continuación se muestra un ejemplo válido para crear una etiqueta:
label_LED_gpio = Label(LED_def, text = “Seleccionar GPIO”) # LED_def es el nombre de la ventana o marco principal
El padre de un objeto de etiqueta puede ser la ventana principal, una ventana secundaria o un marco. Un objeto de etiqueta tiene estas opciones de configuración:
La fuente del texto de una etiqueta se puede especificar como una tupla donde el primer elemento debe ser la familia de fuentes y el segundo debe ser el tamaño de fuente en puntos de impresora. Luego hay otros posibles modificadores de estilo opcionales, como peso, inclinación, subrayado o trazo excesivo.
También se puede crear un objeto de fuente después de importar el paquete de fuentes Tkinter. Se puede crear una fuente creando una instancia de un objeto de fuente usando esta sintaxis:
Fuente1 = fuente.Fuente(opciones,….)
Las opciones son:
- Familia de fuentes: estándar, específica de la plataforma o con nombre
- Tamaño de fuente: en puntos de impresora
- Peso: normal o negrita
- Inclinada: romana o cursiva
- Subrayado: establezca "1" para texto subrayado o "0" para texto normal.
- Sobretachar: establecido en “1” para texto sobretachado y “0” para normal
En una definición de fuente, la familia de fuentes y el tamaño de fuente son opciones obligatorias y el resto son opcionales. Después de crear un objeto de fuente, se le puede asignar el atributo de fuente de cualquier widget. Este es un ejemplo válido de creación y uso de un objeto fuente:
desde la fuente de importación de tkinter
etiquetas_font = font.Font(familia='Helvetica', tamaño=12, peso='negrita')
label_LED_gpio = Etiqueta(LED_def, texto = “Seleccionar GPIO”, fuente=labels_font)
También puedes mostrar un mapa de bits o una imagen estática en una etiqueta. Los mapas de bits disponibles en Tkinter incluyen: error, reloj de arena, información, encabezado de invitado, pregunta, advertencia, gris75, gris50, gris25 y gris12.
Si al mapa de bits se le asigna una etiqueta, el texto no se mostrará en él. En cambio, se muestra el mapa de bits en lugar del texto. La fuente del texto de una etiqueta se puede especificar como una tupla, donde el primer elemento debe ser la familia de fuentes y el segundo debe ser el tamaño de fuente en puntos de impresora. También hay otros modificadores de estilo opcionales, como peso, inclinación, subrayado o trazo excesivo.
Se puede crear un objeto de fuente después de importar el paquete de fuentes Tkinter creando una instancia de un objeto de fuente usando esta sintaxis:
Fuente1 = fuente.Fuente(opciones,….)
Las opciones son:
- Familia de fuentes: estándar, específica de la plataforma o con nombre
- Tamaño de fuente: en puntos de impresora
- Peso: normal o negrita
- Inclinada: romana o cursiva
- Subrayado: establezca "1" para texto subrayado o "0" para texto normal.
- Sobretachar: establecido en “1” para texto sobretachado y “0” para normal
En una definición de fuente, la familia de fuentes y el tamaño de fuente son opciones obligatorias y otras opciones son opcionales. Después de crear un objeto de fuente, se le puede asignar el atributo de fuente de cualquier widget. Este es un ejemplo válido de creación y uso de un objeto fuente:
desde la fuente de importación de tkinter
etiquetas_font = font.Font(familia='Helvetica', tamaño=12, peso='negrita')
label_LED_gpio = Etiqueta(LED_def, texto = “Seleccionar GPIO”, fuente=labels_font)
Para incluir una imagen estática, se debe importar la biblioteca de imágenes Python (PIL) de Tkinter o su versión reciente, Pillow. Sin embargo, el paquete PIL no viene incluido con Python. Por lo tanto, tendrás que instalarlo ejecutando el siguiente comando en el shell (shell Bash en Raspberry Pi):
almohadilla de instalación de pipas
Esta declaración puede importar el PIL o su versión actualizada, llamada Pillow:
desde PIL ImageTk importación, imagen
A continuación, deberá crear un objeto de imagen utilizando el método PhotoImage de la clase ImageTk. Al objeto de imagen se le debe asignar su atributo de imagen. A continuación se muestra un ejemplo válido de cómo incluir una imagen en una etiqueta:
desde PIL ImageTk importación, imagen
myimg = ImageTk.PhotoImage(Imagen.open('minhaimagem.png'))
etiqueta = etiqueta (raíz, imagen = myhaimg)
etiqueta.grid
Para abrir una imagen en un objeto de imagen, también se puede utilizar esta sintaxis:
myimg = ImageTk.PhotoImage(archivo = 'minhaimagem.png')
Tk admite imágenes GIF y PPM/PNM. Tk 8.6 también admite imágenes PNG. Después de instalar PIL, también se incluye soporte para muchos otros formatos de imagen (como BMP, JPEG, PNG, TIFF).
Cuando se utiliza PIL/Pillow, las imágenes se pueden rellenar en etiquetas o como un lienzo que es hijo de la ventana principal o hijo de un marco dentro de la ventana principal. Sin embargo, PIL/Pillow no completa imágenes más allá de esta jerarquía. Por ejemplo, no puede rellenar imágenes en un marco dentro de otro marco, que es hijo de la ventana principal.
El texto de una etiqueta se puede vincular a una variable utilizando el atributo textvariable. De esta manera el texto se puede actualizar o cambiar en el código. Este es un ejemplo válido de cómo vincular el texto de una etiqueta a una variable de tipo StringVar:
desde la importación de tkinter *
desde tkinter importar ttk
función definida:
variable global
var.set ("¡El texto ha sido cambiado!")
raíz = Tk
root.title (“Texto de etiqueta dinámica”)
raíz.minsize(200, 200)
var = CadenaVar
etiqueta = etiqueta (raíz, variable de texto = var, padx = 50, pady = 50)
var.set(“Haga clic en el botón para cambiar el texto de esta etiqueta”)
etiqueta.paquete
botón = botón (raíz, texto = “Cambiar texto”, comando = func)
botón.paquete
raíz.mainloop
Las etiquetas sirven como contenedores de texto e imágenes, que se utilizan para indicar la funcionalidad o el propósito de otros widgets. Pero aún puedes vincularles eventos del mouse.
Cuadro combinado: proviene del paquete ttk. Muestra una lista de valores de texto entre los que un usuario puede seleccionar uno.
El cuadro combinado se ve así:
Se puede crear un cuadro combinado creando una instancia del objeto del cuadro combinado. Se puede crear una instancia de un objeto de cuadro combinado utilizando el método Combobox de la clase ttk. La definición de un objeto de cuadro combinado tiene esta sintaxis:
var = ttk.Combobox(padre, (opciones de configuración,….) #ttk es una referencia a la clase ttk
Este es un ejemplo válido de creación de un cuadro combinado:
combo_LED_config = ttk.Combobox(LED_def, valores =(“Modo fuente”, “Modo sumidero”))
El padre de un objeto de cuadro combinado puede ser la ventana principal, una ventana secundaria o un marco. Un objeto de cuadro combinado tiene estas opciones de configuración:
Los valores de un cuadro combinado se pueden especificar mediante una lista o tupla de Python. También puede completar dinámicamente valores en un cuadro combinado utilizando el atributo textvariable. Los valores pueden ser cadenas o números.
El cuadro combinado se utiliza para permitir al usuario realizar una selección de una lista de valores (de texto o numéricos). También puede vincular eventos de teclado y mouse con un cuadro combinado. Sin embargo, lo más importante es un evento virtual asociado. Este evento virtual es “<
Se puede seleccionar un valor predeterminado del cuadro combinado utilizando el método actual, con el índice del valor deseado pasado como argumento. Debido a que los valores de un cuadro combinado se toman de una lista o tupla, el índice comienza en "0".
Si el método actual se usa sin argumentos en un objeto de cuadro combinado, devuelve el índice del valor seleccionado actualmente, o "-1" si no se selecciona ningún valor. El método get devuelve el valor seleccionado actualmente en el cuadro combinado. El método set(value) le permite establecer el valor seleccionado del cuadro combinado en el valor que se pasa como argumento.
En el siguiente ejemplo, podemos completar los pines GPIO del RPI usando un cuadro combinado.
Otros métodos disponibles para el objeto de cuadro combinado incluyen: cget, configure, verificar, instate y state.
El cuadro combinado es una subclase de Entry. De la clase Entry, hereda los métodos bbox, eliminar, icursor, index, insertar, selección y xview.
Entrada: acepta una sola línea de cadena de texto del usuario.
Se parece a esto:
Se puede crear una entrada creando una instancia de un objeto de entrada utilizando el método Entry de Tkinter o la clase ttk. La definición de un objeto de entrada tiene esta sintaxis:
var = Entrada(padre, (opciones de configuración,….)
Este es un ejemplo válido de creación de una entrada:
input_LED_duration = entrada(LED_def)
El padre de un objeto de entrada puede ser la ventana principal, una ventana secundaria o un marco. El objeto de entrada tiene estas opciones de configuración:
Las entradas se utilizan para obtener entradas de texto numéricas o de una sola línea de un usuario. El valor numérico o de texto ingresado por el usuario se puede recuperar utilizando el método get de la entrada. Un elemento invocable se puede vincular a la Entrada para cualquier cambio en su estado (el estado del contenido de la Entrada, no el estado del widget) asignándolo al atributo de comando.
Normalmente, un invocable está vinculado a la entrada mediante el atributo de comando para la validación de datos. Los eventos de teclado o mouse se pueden vincular a una entrada mediante el método de vinculación. En este caso, el invocable (controlador de eventos) tendrá el evento como uno de sus argumentos.
Estos métodos están disponibles para el widget de entrada:
Texto: acepta texto de varias líneas de un usuario como un objeto de cadena.
Se parece a esto:
Se puede crear un widget de texto creando una instancia del objeto de texto. Se puede crear una instancia del objeto de texto utilizando el método Text de Tkinter o la clase ttk. La definición de un objeto de texto tiene esta sintaxis:
var = Texto(padre, (opciones de configuración,….)
Este es un ejemplo válido de creación de un widget de texto:
text_cLCD_message = Text(cLCD_init) #cLCD_init es el nombre del marco o ventana principal
El padre de un objeto de texto puede ser la ventana principal, una ventana secundaria o un marco. El objeto de texto tiene estas opciones de configuración:
Cabe señalar que el widget de texto no tiene atributos de comando ni de variable de texto. El texto de varias líneas ingresado por el usuario en el widget de texto se puede recuperar mediante el método get. Los eventos de teclado o mouse se pueden vincular a un widget de texto mediante el método de vinculación. El widget de texto admite algunas estructuras auxiliares como pestañas, etiquetas y tabla de contenido que son útiles para dar formato al contenido del texto. Los siguientes métodos están disponibles para el widget de texto:
El widget de texto tiene métodos adicionales para pestañas, etiquetas y tabla de contenido.
El índice del widget de texto tiene el formato número_línea.posición_carácter. Por lo tanto, "1.0" se refiere al carácter en la posición "0" en la línea "1".
Las palabras clave, como inicio de línea, final de línea, inserción, fin, inicio de palabra, final de palabra y caracteres, se pueden utilizar como índice o como parte del índice.
Por ejemplo:
- “2.2 inicio de línea” se refiere al primer carácter de la línea 2
- “2.2 final de línea” se refiere a la nueva línea al final de la línea 2
- “2.0 + 3 caracteres” se refiere a tres caracteres más allá de la línea 2... y así sucesivamente
Botón de verificación: permite al usuario seleccionar valores para una opción, que puede ser más de uno a la vez. Estos botones contienen valores binarios que un usuario puede alternar. Cuando el usuario cambia el valor, se puede invocar una devolución de llamada de comando.
Los botones de verificación se ven así:
Se puede crear un botón de verificación creando una instancia del objeto Botón de verificación. Se puede crear una instancia del objeto Checkbutton utilizando el método Checkbutton de Tkinter o la clase ttk. La definición de un objeto Checkbutton tiene esta sintaxis:
var = Botón de verificación (padre, (opciones de configuración,….)
Este es un ejemplo válido de creación de un botón de verificación:
bandera_animación = StringVar
check_cLCD_animate = Checkbutton(cLCD_int, text = “Animate Text”, comando = cLCD_Text_Animation, variable = Animation_flag) #cLCD_init es el nombre del marco o ventana principal
El padre de un botón de verificación puede ser la ventana principal, una ventana secundaria o un marco. El botón de verificación tiene estas opciones de configuración:
El botón de verificación se puede activar o desactivar todos a la vez y combinar con una variable para controlar su estado de alternancia. Al configurar los atributos "onvalue" y "offvalue", se pueden recuperar valores no booleanos cuando cambia su estado.
Se puede asignar un elemento invocable a su atributo de comando para ejecutar el comportamiento del código durante la interacción del usuario. Un invocable también se puede ejecutar utilizando el método Invoke.
No existe ninguna lógica para vincular eventos de teclado o mouse a un botón de verificación. Sin embargo, los eventos del mouse se pueden vincular a un botón de verificación utilizando el método de vinculación para obtener algún tipo de efecto gráfico.
El botón de verificación tiene estos métodos disponibles:
Botón de opción: permite al usuario seleccionar solo un valor entre varios valores para una opción. Esto se puede hacer usando la tecla Tab para navegar a través de los valores disponibles. Un grupo de Radiobuttons debe estar asociado con una única variable y cada uno debe contener un valor único.
Los botones de opción se ven así:
Se puede crear un botón de radio creando una instancia del objeto Botón de radio. Se puede crear una instancia del objeto Radiobutton utilizando el método Radiobutton de Tkinter o la clase ttk. La definición de un objeto Radiobutton tiene esta sintaxis:
var = Botón de radio(padre, (opciones de configuración,….)
Este es un ejemplo válido para crear un botón de radio:
modo_vigilancia = StringVar
radio_datetime_mode = Radiobutton(watch_int, variable = watch_mode, text = “Mostrar solo fecha y hora”) #watch_init es el nombre del marco o ventana principal
radio_datetimetemp_mode = Radiobutton (watch_int, variable = watch_mode, text = “Mostrar fecha, hora y temperatura”)
radio_datetime_temp_hum_mode = Radiobutton(watch_int, variable = watch_mode, text = “Mostrar fecha, hora, temperatura y humedad”)
El padre de un botón de radio puede ser la ventana principal, una ventana secundaria o un marco. El botón de radio tiene estas opciones de configuración:
Además, la variable de control puede rastrear el estado de un botón de radio y puede contener un valor numérico o de cadena asignado al botón de radio seleccionado. El comportamiento del código se puede agregar a un objeto Radiobutton asignando un elemento invocable a su atributo de comando.
También es posible ejecutar un invocable utilizando el método Invoke. Sin embargo, no tiene sentido vincular eventos de teclado o mouse a un botón de radio usando el método de vinculación, aunque algunos eventos del mouse se pueden usar para animar ciertos efectos gráficos en un botón de radio.
El botón de radio tiene estos métodos:
Botón: permite a los usuarios realizar determinadas acciones. Puede mostrar texto o imágenes en los botones para indicar su propósito. Los botones están asociados con un elemento invocable que debe ejecutarse cuando un usuario lo presiona.
Los botones se ven así:
Se puede crear un botón creando una instancia del objeto Botón. Se puede crear una instancia del objeto Button utilizando el método Button de Tkinter o la clase ttk. La definición de un objeto Botón tiene esta sintaxis:
var = Botón(padre, (opciones de configuración,….)
Aquí hay un ejemplo válido para crear un botón:
button_LED_signal = Botón(LED_def, texto = “Generar señal”, comando = thread_generate_LED_signal) #LED_def es el nombre de la ventana o marco principal
El padre de un botón puede ser la ventana principal, una ventana secundaria o un marco. El botón tiene estas opciones de configuración:
El comportamiento del código se puede agregar a un botón asignando un elemento invocable a su atributo de comando. Un invocable también se puede ejecutar usando el método Invoke en el objeto Button.
De forma predeterminada, se debe ejecutar una llamada cuando un usuario presiona el botón. No es necesario vincular otros eventos de teclado o mouse a un objeto Botón. Sin embargo, puede resultar útil vincular algunos eventos de teclado a un botón utilizando el método de vinculación cuando necesite realizar una acción mediante atajos de teclado.
Podemos diseñar la mayoría de las interfaces para nuestras recetas RPi con estos widgets. Si incluimos otros widgets en nuestra GUI de recetas, los mostraremos en ese momento.
En el próximo tutorial , analizaremos los menús Tkinter/ttk, la gestión de diseño, el enlace de eventos y el subproceso múltiple. Esto será suficiente para probar nuestra primera receta de Raspberry Pi: un controlador LED.
Hazlo tu mismo
Si tiene experiencia con microcontroladores, intente adivinar el uso de diferentes widgets Tkinter/ttk para controlar operaciones integradas. Por ejemplo, podemos usar un widget de escala para controlar el ciclo de trabajo de una señal PWM o para controlar la velocidad de un motor de CC.
También podemos usar los widgets Entrada o Texto para contener mensajes de texto que se pueden pasar a una pantalla LCD de caracteres presionando un botón. Según su experiencia con microcontroladores, piense en situaciones en las que podría utilizar diferentes widgets Tkinter/ttk en aplicaciones integradas. Además, tenga en cuenta situaciones en las que podría estar leyendo datos de sensores.
Intente evaluar estas situaciones y las posibles dificultades que puede enfrentar al utilizar los widgets Tkinter/ttk para controlar diferentes componentes de hardware.
Un ejemplo es que el widget de texto no tiene una “variable de texto” o atributo de comando. En este caso, ¿será posible pasar mensajes de texto dinámicos desde un widget de texto a una pantalla LCD de caracteres? ¡Empiece a hacer una lluvia de ideas!