Programação RPi Python 12: widgets Tkinter e TTK

No tutorial anterior, aprendemos sobre o widget de janela no Tkinter e projetamos uma janela principal da GUI em branco (que não é filho de nenhuma outra janela no aplicativo GUI). Janelas filhas servem como contêiner para outros widgets

Não faz sentido ter janelas em branco, portanto deve haver outros widgets incluídos no widget da janela para facilitar a interação com o usuário. Os widgets contidos em um widget de janela são filhos dessa janela.

Widgets Tk
Tk é um kit de ferramentas de interface de usuário multiplataforma. Ele pode ser usado para projetar interfaces gráficas de usuário para sistemas X11, Microsoft Windows e Mac OS X. Atualmente, as linguagens de programação que usam Tk como kit de ferramentas GUI incluem Python, Ruby, Pearl e Tcl.

Uma GUI consiste em vários widgets dispostos em um widget contêiner. Widgets podem ser vistos como elementos gráficos que fornecem um tipo específico de interação e funcionalidade na interface do usuário. O widget de contêiner de nível superior é sempre uma janela.

Tk fornece vários widgets para interfaces de tipo de formulário de preenchimento, bem como menus, janelas, caixas de diálogo padrão e imagens. Ele também oferece suporte a cores, fontes, estilos e temas para interfaces de usuário.

Os widgets que foram originalmente incluídos no pacote são chamados de widgets clássicos e são empacotados como o módulo Tkinter. O Tk 8.5 adicionou recentemente um novo conjunto de widgets temáticos, que estão disponíveis como um pacote ttk. No entanto, o pacote ttk precisa ser importado separadamente se estiver interessado em usar esses novos widgets com o Tkinter.

Os widgets são incluídos em um aplicativo GUI como objetos de classe, cada um com sua própria aparência e funcionalidade. Isso significa que todos os widgets são subclasses de Tkinter/ttk e é necessário instanciar os objetos dessas classes para incluir os widgets em nossa GUI.

Tkinter não possui um editor WYSIWYG. Portanto, para criar cada widget, precisaremos escrever código para ele e gerenciar os widgets dentro desse código. O gerenciamento de qualquer widget normalmente envolve três operações:

1. Configurando a aparência do widget
2. Configurando o layout do widget
3. Adicionando funcionalidade ou comportamento ao widget

No Tkinter, a aparência de um widget pode ser estabelecida definindo as opções de configuração disponíveis para ele. No código, essas configurações são determinadas pela definição dos atributos disponíveis para esse objeto de classe de widget.

Definir o layout do widget significa onde e como o widget deve aparecer no widget contêiner (ou seja, na janela ou quadro). Tkinter fornece três tipos de gerenciamento de layout (geometria): posicionamento absoluto, layout de pacote e layout de grade.

Os widgets podem ser organizados como um desses tipos chamando os métodos place , pack ou grid . As opções de configuração de um widget podem ser definidas a qualquer momento antes ou depois de chamar um método de gerenciamento de layout no widget. Entretanto, até que um dos métodos de gerenciamento de layout (local, pacote ou grade) seja chamado para um objeto widget, ele não aparecerá no widget contêiner.

Os aplicativos GUI são sempre orientados a eventos e cada widget tem seu próprio conjunto de eventos disponíveis. Esses eventos são acionados pela interação do usuário. Por exemplo, o usuário pode acionar um evento e um bloco de código será executado em resposta a ele.

O processo de escrever um comportamento de código para um evento (widget) é chamado de vinculação de evento. O bloco de código executado em resposta a um evento (widget) é chamado de manipulador de eventos. O manipulador de eventos deve ser chamável para que possa ser uma função ou um atributo/método chamável de um objeto de classe.

Adicionar funcionalidade ou comportamento de código a um widget no Tkinter é o mesmo que vincular eventos para esse widget. A vinculação de eventos a um widget pode ser feita atribuindo um chamável (função ou método de classe) ao atributo de comando (se estiver disponível para esse widget) ou usando o método bind .

O pacote Tkinter com ttk (além de janelas, caixas de diálogo padrão, menus e imagens) oferece estes widgets básicos:

  • Quadro
  • Rótulo
  • Botão
  • Botão de verificação
  • Botao de radio
  • Entrada
  • Caixa combo
  • Caixa de listagem
  • Barra de rolagem
  • Tamanhogrip
  • Texto
  • Barra de progresso
  • Escala
  • Caixa giratória
  • Separador
  • Quadro de etiqueta
  • Janela panorâmica
  • Caderno
  • Tela
  • Vista em árvore

Frame, Label, Button, Checkbutton, Radiobutton, Entry e Combobox são widgets para o tipo de interface de preenchimento de formulário. Listbox, Scrollbar, Sizegrip, Text, Progressbar, Scale e Spinbox são widgets adicionais para fins específicos. Frame, Labelframe, Panedwindow e Notebook servem como widgets de contêiner dentro dos widgets de janela.

O widget Treeview exibe uma lista de itens organizados em ordem hierárquica. O widget de tela é um widget poderoso que pode ser usado para desenhar, diagramar ou criar outros widgets complexos. O Separador é um widget de apresentação que pode ser usado para separar dois grupos diferentes de widgets.

Dos widgets mencionados acima, Combobox, Notebook, Separator, Progressbar, Sizegrip e Treeview são novos widgets que vêm apenas com o pacote ttk.

Freqüentemente usaremos widgets Frame, Label, Combobox, Entry, Text, Checkbutton, Radiobutton e Button na GUI para nossas receitas Raspberry Pi. Esses widgets são descritos abaixo:

Quadro – serve como um widget de contêiner dentro de widgets de janela. São contêineres retangulares excelentes para agrupar e ordenar outros widgets. Um quadro é usado como classe pai para outros objetos widget (classe) contidos nele.

Os quadros ficam assim:

Um quadro pode ser criado instanciando um objeto de quadro. O objeto frame pode ser instanciado usando o método Frame do tkinter ou a classe ttk. A definição de um objeto frame possui esta sintaxe:

var = Frame(pai, (opções de configuração,….)

Este é um exemplo válido de criação de um quadro:

LED_def = Frame(root) # root é o nome da janela pai:

Um quadro em si é um widget contêiner que só pode ser criado dentro de um widget de janela. O pai do objeto frame pode ser a janela principal ou qualquer janela filha. O “pai” é um argumento obrigatório que deve ser passado para uma definição de quadro. As opções de configuração, que alteram a aparência do widget, são argumentos opcionais.

Um objeto frame possui estas opções de configuração:

As cores (como bg) no Tkinter são atribuídas como strings, que podem ser valores hexadecimais para cores (como “#fff”, #fdfdfd, etc.) ou nomes de cores (como “vermelho”, “azul”, “ verde” etc.).

Deve-se observar que todas as dimensões (largura da borda, preenchimento, etc.) definidas como um número inteiro assumirão um valor em pixels. As dimensões podem receber uma unidade sufixando o valor pelos seguintes indicadores:

Por padrão, os quadros não possuem bordas. Se um atributo “bd” receber um valor e um atributo “relevo” receber um valor (diferente de plano), o quadro terá uma borda com essa largura e estilo. O atributo relevo determina o estilo da borda.

Os estilos de relevo suportados no Tkinter são plano, elevado, afundado, ranhura e cume. Se o quadro tiver um estilo de relevo atribuído como “plano”, sua borda não será exibida.

Os cursores do mouse suportados no Tkinter incluem: seta, círculo, relógio, cruz, dotbox, troca, flor, coração, homem, mouse, pirata, plus, transporte, dimensionamento, aranha, lata de spray, estrela, alvo, tcross, caminhada e relógio . O cursor padrão é “seta”.

As opções de configuração do quadro podem ser definidas como argumentos de pares de valores-chave na definição do quadro ou podem ser definidas explicitamente. Aqui estão dois exemplos válidos de definição de opções de configuração para um quadro:

LED_def = Quadro(raiz, padx = 25, pady = 10)
LED_def.grid
ou
LED_def = Quadro(raiz)
LED_def.grid
LED_def(“padx”)= 25
LED_def(“pady”)= 10

Os frames servem apenas como widgets contêineres para outros widgets básicos e não envolvem vinculação de eventos.

Rótulo – serve como recipientes para texto e imagens. O texto dentro de uma etiqueta pode ser atualizado ou alterado. Geralmente, os rótulos são usados ​​para indicar a finalidade de outros widgets na interface.

Os rótulos ficam assim:

Um rótulo pode ser criado instanciando um objeto rótulo. Um objeto rótulo pode ser instanciado usando o método Label do Tkinter ou a classe ttk. A definição de um objeto rótulo possui esta sintaxe:

var = Label(pai, (opções de configuração,….)

Aqui está um exemplo válido para criar um rótulo:

label_LED_gpio = Label(LED_def, text = “Select GPIO”) # LED_def é o nome da janela ou quadro pai

O pai de um objeto rótulo pode ser a janela principal, uma janela filha ou um quadro. Um objeto rótulo possui estas opções de configuração:

A fonte do texto em uma etiqueta pode ser especificada como uma tupla em que o primeiro elemento deve ser a família da fonte e o segundo deve ser o tamanho da fonte nos pontos da impressora. Depois, existem outros modificadores de estilo opcionais possíveis, como peso, inclinação, sublinhado ou traço excessivo.

Um objeto de fonte também pode ser criado após importar o pacote de fontes do Tkinter. Uma fonte pode ser criada instanciando um objeto de fonte usando esta sintaxe:

Fonte1 = fonte.Font(opções,….)

As opções são:

  • Família de fontes – padrão, específica da plataforma ou uma fonte nomeada
  • Tamanho da fonte – nos pontos da impressora
  • Peso – normal ou negrito
  • Inclinação – romana ou itálica
  • Sublinhado – definido como “1” para texto sublinhado ou “0” para texto normal
  • Overstrike – definido como “1” para texto com overstrike e “0” para normal

Em uma definição de fonte, a família e o tamanho da fonte são opções obrigatórias e as demais são opcionais. Depois de criar um objeto de fonte, ele pode ser atribuído ao atributo de fonte de qualquer widget. Este é um exemplo válido de criação e uso de um objeto fonte:

da fonte de importação tkinter
rótulos_font = font.Font(family='Helvetica', tamanho=12, peso='bold')
label_LED_gpio = Label(LED_def, text = “Selecionar GPIO”, font=labels_font)

Também é possível mostrar um bitmap ou uma imagem estática em uma etiqueta. Os bitmaps disponíveis no Tkinter incluem: erro, ampulheta, informações, guesthead, pergunta, aviso, cinza75, cinza50, cinza25 e cinza12.

Se o bitmap for atribuído a um rótulo, o texto não será exibido nele. Em vez disso, o bitmap é exibido no lugar do texto. A fonte do texto em uma etiqueta pode ser especificada como uma tupla, onde o primeiro elemento deve ser a família da fonte e o segundo deve ser o tamanho da fonte nos pontos da impressora. Existem também outros modificadores de estilo opcionais, como peso, inclinação, sublinhado ou traço excessivo.

Um objeto de fonte pode ser criado após importar o pacote de fontes do Tkinter instanciando um objeto de fonte usando esta sintaxe:

Fonte1 = fonte.Font(opções,….)

As opções são:

  • Família de fontes – padrão, específica da plataforma ou uma fonte nomeada
  • Tamanho da fonte – nos pontos da impressora
  • Peso – normal ou negrito
  • Inclinação – romana ou itálica
  • Sublinhado – definido como “1” para texto sublinhado ou “0” para texto normal
  • Overstrike – definido como “1” para texto com overstrike e “0” para normal

Em uma definição de fonte, a família e o tamanho da fonte são opções obrigatórias e as demais opções são opcionais. Depois de criar um objeto de fonte, ele pode ser atribuído ao atributo de fonte de qualquer widget. Este é um exemplo válido de criação e uso de um objeto fonte:

da fonte de importação tkinter
rótulos_font = font.Font(family='Helvetica', tamanho=12, peso='bold')
label_LED_gpio = Label(LED_def, text = “Selecionar GPIO”, font=labels_font)

Para incluir uma imagem estática, a Python Image Library (PIL) do Tkinter ou sua versão recente, Pillow, deve ser importada. No entanto, o pacote PIL não vem junto com o Python. Portanto, você terá que instalá-lo executando o seguinte comando no shell (shell Bash no Raspberry Pi):

almofada de instalação pip

Esta declaração pode importar o PIL ou sua versão atualizada, chamada Pillow:

da importação PIL ImageTk, imagem

A seguir, você precisará criar um objeto de imagem usando o método PhotoImage da classe ImageTk. O objeto de imagem deve ser atribuído ao seu atributo de imagem. Aqui está um exemplo válido de inclusão de uma imagem em um rótulo:

da importação PIL ImageTk, imagem
minhaimg = ImageTk.PhotoImage(Image.open('minhaimagem.png'))

rótulo = rótulo(raiz, imagem=minhaimg)
rótulo.grid

Para abrir uma imagem em um objeto de imagem, esta sintaxe também pode ser usada:

minhaimg = ImageTk.PhotoImage(arquivo = 'minhaimagem.png')

Tk suporta imagens GIF e PPM/PNM. Tk 8.6 também suporta imagens PNG. Após a instalação do PIL, o suporte para muitos outros formatos de imagem (como BMP, JPEG, PNG, TIFF) também está incluído.

Ao usar PIL/Pillow, as imagens podem ser preenchidas em rótulos ou como uma tela que é filha da janela pai ou filha de um quadro dentro da janela pai. Porém, o PIL/Pillow não preenche imagens além dessa hierarquia. Por exemplo, ele não consegue preencher imagens em um quadro dentro de outro quadro, que é filho da janela pai.

O texto de um rótulo pode ser vinculado a uma variável usando o atributo textvariable. Desta forma o texto pode ser atualizado ou alterado no código. Este é um exemplo válido de vinculação do texto de um rótulo a uma variável do tipo StringVar:

da importação do tkinter *
de tkinter importar ttk
função def :
variável global
var.set(“O texto foi alterado!”)
raiz = Tk
root.title (“Texto dinâmico do rótulo”)
raiz.minsize(200, 200)
var = StringVar
rótulo = rótulo (raiz, variável de texto = var, padx = 50, pady = 50)
var.set(“Clique no botão para alterar o texto deste rótulo”)
rótulo.pack
botão = botão (raiz, texto = “Alterar texto”, comando = func)
botão.pack
raiz.mainloop

Os rótulos servem como contêineres para texto e imagens, que são usados ​​para indicar a funcionalidade ou a finalidade de outros widgets. Mas ainda é possível vincular eventos de mouse a eles.

Caixa combo – vem do pacote ttk. Ele exibe uma lista de valores de texto dos quais um usuário pode selecionar um.

A Combobox fica assim:

Uma combobox pode ser criada instanciando o objeto combobox. Um objeto combobox pode ser instanciado usando o método Combobox da classe ttk. A definição de um objeto combobox possui esta sintaxe:

var = ttk.Combobox(parent, (opções de configuração,….) #ttk é referência à classe ttk

Este é um exemplo válido de criação de uma caixa de combinação:

combo_LED_config = ttk.Combobox(LED_def, valores=(“Modo Fonte”, “Modo Dissipador”))

O pai de um objeto combobox pode ser a janela principal, uma janela filha ou um quadro. Um objeto combobox possui estas opções de configuração:

Os valores de uma caixa de combinação podem ser especificados por uma lista ou tupla Python. Também é possível preencher dinamicamente valores em uma caixa de combinação usando o atributo textvariable. Os valores podem ser strings ou números.

A caixa de combinação é usada para permitir ao usuário fazer uma seleção em uma lista de valores (texto ou numérico). Também é possível vincular eventos de teclado e mouse com uma caixa de combinação. Porém, o mais importante é um evento virtual associado a ele. Este evento virtual é “<>” e é acionado quando um usuário faz uma seleção no combobox. Um callable (método de função/classe) pode ser vinculado a este evento usando o método bind .

Um valor padrão pode ser selecionado na caixa de combinação usando o método current nela, com o índice do valor desejado passado como argumento. Como os valores em uma caixa de combinação são retirados de uma lista ou tupla, o índice começa em “0”.

Se o método current for usado sem argumentos em um objeto combobox, ele retornará o índice do valor atualmente selecionado ou “-1” se nenhum valor for selecionado. O método get retorna o valor atualmente selecionado da caixa de combinação. O método set(value) permite definir o valor selecionado da combobox para o valor que é passado como argumento.

No exemplo a seguir, podemos preencher os pinos GPIO do RPI usando uma caixa de combinação.

Outros métodos disponíveis para o objeto combobox incluem: cget , configure , verify , instate e state .

A combobox é uma subclasse de Entry. Da classe Entry, ele herda os métodos bbox , delete , icursor , index , insert , selection e xview .

Entrada – aceita uma única linha da string de texto do usuário.

Se parece com isso:

Uma entrada pode ser criada instanciando um objeto de entrada usando o método Entry do Tkinter ou a classe ttk. A definição de um objeto de entrada possui esta sintaxe:

var = Entry(pai, (opções de configuração,….)

Este é um exemplo válido de criação de uma entrada:

entrada_LED_duration = Entrada(LED_def)

O pai de um objeto de entrada pode ser a janela principal, uma janela filha ou um quadro. O objeto de entrada possui estas opções de configuração:

As entradas são usadas para obter entrada de texto numérico ou de linha única de um usuário. O valor numérico ou de texto inserido pelo usuário pode ser recuperado usando o método get da entrada. Um chamável pode ser vinculado à Entrada para qualquer alteração em seu estado (o estado do conteúdo da Entrada — não o estado do widget) atribuindo isso ao atributo de comando.

Geralmente, um chamável é vinculado à entrada por meio do atributo de comando para validação de dados. Eventos de teclado ou mouse podem ser vinculados a uma entrada usando o método bind . Nesse caso, o chamável (manipulador de eventos) terá o evento como um de seus argumentos.

Estes métodos estão disponíveis para o widget Entrada:

Texto – aceita texto multilinha de um usuário como um objeto string.

Se parece com isso:

Um widget de texto pode ser criado instanciando o objeto de texto. O objeto de texto pode ser instanciado usando o método Text do Tkinter ou a classe ttk. A definição de um objeto de texto possui esta sintaxe:

var = Text(pai, (opções de configuração,….)

Este é um exemplo válido de criação de um widget de texto:

text_cLCD_message = Text(cLCD_init) #cLCD_init é o nome do quadro ou janela pai

O pai de um objeto de texto pode ser a janela principal, uma janela filha ou um quadro. O objeto de texto possui estas opções de configuração:

Deve-se observar que o widget de texto não possui atributos de comando e variável de texto. O texto multilinha inserido pelo usuário no widget Texto pode ser recuperado usando o método get . Os eventos de teclado ou mouse podem ser vinculados a um widget de texto usando o método bind . O widget de texto suporta algumas estruturas auxiliares como Guias, Marcas e Índice que são úteis na formatação do conteúdo do texto. Os seguintes métodos estão disponíveis para o widget Texto:

O widget de texto possui métodos adicionais para guias, marcas e índice.

O índice do widget de texto tem o formato line_number.character_position. Portanto, “1.0” refere-se ao caractere na posição “0” na linha “1”.

Palavras-chave — como linestart, lineend, insert, end, wordstart, wordend e chars — podem ser usadas como um índice ou parte do índice.

Por exemplo:

  • “2.2 linestart” refere-se ao primeiro caractere da linha 2
  • “2.2 lineend” refere-se à nova linha no final da linha 2
  • “2.0 + 3 caracteres” refere-se a três caracteres além da linha 2… e assim por diante

Botão de verificação – permite ao usuário selecionar valores para uma opção, que pode ser mais de um por vez. Esses botões contêm valores binários que um usuário pode alternar. Quando o usuário alterna o valor, um retorno de chamada de comando pode ser invocado.

Os botões de verificação ficam assim:

Um Checkbutton pode ser criado instanciando o objeto Checkbutton. O objeto Checkbutton pode ser instanciado usando o método Checkbutton do Tkinter ou a classe ttk. A definição de um objeto Checkbutton possui esta sintaxe:

var = Checkbutton(pai, (opções de configuração,….)

Este é um exemplo válido de criação de um Checkbutton:

animação_flag = StringVar
check_cLCD_animate = Checkbutton(cLCD_int, text = “Animate Text”, command = cLCD_Text_Animation, variável = Animation_flag) #cLCD_init é o nome do quadro ou janela pai

O pai de um Checkbutton pode ser a janela principal, uma janela filha ou um quadro. O Checkbutton possui estas opções de configuração:

O Checkbutton pode ser definido ou desmarcado de uma só vez e emparelhado com uma variável para manter uma verificação em seu estado de alternância. Ao definir os atributos “onvalue” e “offvalue”, os valores não booleanos podem ser recuperados quando seu estado for alterado.

Um callable pode ser atribuído ao seu atributo de comando para executar o comportamento do código durante a interação do usuário. Um callable também pode ser executado usando o método Invoke .

Não há lógica para vincular eventos de teclado ou mouse a um Checkbutton. Porém, os eventos do mouse podem ser vinculados a um Checkbutton usando o método bind para algum tipo de efeito gráfico.

O Checkbutton tem estes métodos disponíveis:

Botao de radio – permite que um usuário selecione apenas um valor entre vários valores para uma opção. Isso pode ser feito usando a tecla Tab para navegar pelos valores disponíveis. Um grupo de Radiobuttons deve estar associado a uma única variável e cada um deve conter um valor único.

Os botões de opção ficam assim:

Um Radiobutton pode ser criado instanciando o objeto Radiobutton. O objeto Radiobutton pode ser instanciado usando o método Radiobutton do Tkinter ou a classe ttk. A definição de um objeto Radiobutton possui esta sintaxe:

var = Radiobutton(pai, (opções de configuração,….)

Este é um exemplo válido para criar um Radiobutton:

watch_mode = StringVar
radio_datetime_mode = Radiobutton(watch_int, variável = watch_mode, text = “Exibir apenas data e hora”) #watch_init é o nome do quadro ou janela pai
radio_datetimetemp_mode = Radiobutton (watch_int, variável = watch_mode, texto = “Exibir data, hora e temperatura”)
radio_datetime_temp_hum_mode = Radiobutton (watch_int, variável = watch_mode, texto = “Exibir data, hora, temperatura e umidade”)

O pai de um Radiobutton pode ser a janela principal, uma janela filha ou um quadro. O Radiobutton possui estas opções de configuração:

Além disso, a variável de controle pode rastrear o status de um Radiobutton e pode conter um valor numérico ou de string atribuído ao Radiobutton selecionado. O comportamento do código pode ser adicionado a um objeto Radiobutton atribuindo um callable ao seu atributo de comando.

Também é possível executar um callable usando o método Invoke . No entanto, não faz sentido vincular eventos de teclado ou mouse a um Radiobutton usando o método bind , embora alguns eventos de mouse possam ser usados ​​para animar certos efeitos gráficos em um Radiobutton.

O Radiobutton possui estes métodos:

Botão – permite que os usuários executem determinadas ações. É possível exibir texto ou imagens em botões para indicar sua finalidade. Os botões estão associados a um callable que deve ser executado quando um usuário o pressiona.

Os botões ficam assim:

Um Button pode ser criado instanciando o objeto Button. O objeto Button pode ser instanciado usando o método Button do Tkinter ou a classe ttk. A definição de um objeto Button possui esta sintaxe:

var = Button(pai, (opções de configuração,….)

Aqui está um exemplo válido para criar um botão:

button_LED_signal = Button(LED_def, text = “Generate Signal”, command = thread_generate_LED_signal) #LED_def é o nome da janela ou quadro pai

O pai de um Button pode ser a janela principal, uma janela filha ou um quadro. O Button tem estas opções de configuração:

O comportamento do código pode ser adicionado a um botão atribuindo um callable ao seu atributo de comando. Um callable também pode ser executado usando o método Invoke no objeto Button.

Por padrão, um callable deve ser executado quando um usuário pressiona o botão. Não há necessidade de vincular outros eventos de teclado ou mouse a um objeto Button. Porém, pode ser útil vincular alguns eventos de teclado a um botão usando o método bind quando for necessário executar uma ação por meio de atalhos de teclado.

Podemos projetar a maioria das interfaces para nossas receitas RPi com esses widgets. Se incluirmos quaisquer outros widgets na GUI da nossa receita, iremos apresentá-los então.

No próximo tutorial, discutiremos menus Tkinter/ttk, gerenciamento de layout, vinculação de eventos e multithreading. Isso será suficiente para testar nossa primeira receita do Raspberry Pi – um driver de LED.

Faça Você Mesmo
Se você tem experiência em microcontroladores, tente adivinhar o uso dos diferentes widgets Tkinter/ttk no controle de operações incorporadas. Por exemplo, podemos usar um widget de escala para controlar o ciclo de trabalho de um sinal PWM ou para controlar a velocidade de um motor DC.

Também podemos usar os widgets Entry ou Text para conter mensagens de texto que podem ser passadas para um LCD de caracteres ao pressionar um botão. Com base na sua experiência com microcontroladores, pense em situações em que você pode usar diferentes widgets Tkinter/ttk em aplicativos incorporados. Além disso, lembre-se de situações em que você pode estar lendo dados de sensores.

Tente avaliar essas situações e as possíveis dificuldades que você pode enfrentar ao usar widgets Tkinter/ttk para controlar diferentes componentes de hardware.

Um exemplo é que o widget Texto não possui uma “variável de texto” ou atributo de comando. Neste caso, será possível passar mensagens de texto dinâmicas de um widget de Texto para um LCD de caracteres? Comece o brainstorming!

Conteúdo Relacionado

Voltar para o blog

Deixe um comentário

Os comentários precisam ser aprovados antes da publicação.