Módulos Complementares Python

Nesta lição, vai escrever os seus primeiros programas em python para controlar o display do micro:bit de diferentes formas. Esta lição está dividida em duas partes:

• Parte 1: encontro alienígena
• Parte 2: exibir imagens

Objetivos:

• Controlar a exibição na placa do micro:bit usando .show( ), .scroll( ) e .show(imagem)
• Controlar a velocidade de exibição usando sleep(ms)

Antes de começar, certifique-se que:

• a sua TI-Nspire CX II tem Sistema Operativo 5.3 ou mais recente
• se sente confortável a programar em python e/ou completou as unidades 1 a 5
• -o seu micro:bit está conectado com a tua TI-Nspire CX II
• seguiu as instruções de configuração e transferência de ficheiros no Guia de iniciação do micro:bit :
  https://education.ti.com/pt/teachers/microbit

Este processo de configuração apenas deverá ter de se feito uma vez, mas mantém-te informado periodicamente acerca de atualizações.

Se está tudo bem e a configuração foi realizada corretamente, o seu micro:bit deve apresentar-se assim quando tem energia da TI-Nspire:

O display do micro:bit mostra o logótipo da TI, um ícone do estado do Texas  com um ponto brilhante perto de Dallas, a casa da Texas Instruments, Inc.

E finalmente…

O módulo do micro:bit está instalado na tua Biblioteca Python. Num Editor Python, clica [menu] > Mais módulos e repara que BBC micro:bit se encontra listado na parte de baixo do módulos TI.

Nota: No sistema operativo 5.3 e mais recentes, os módulos de Pyton que estão armazenados na sua pasta Pylib do seu dispositivo aparecem neste menu em adição aos ti_ modules. A sua lista pode diferir da aqui mostrada. Os módulos estão listados alfabeticamente de acordo com o nome do ficheiro, logo BBC micro:bit encontra-se entre os “m’s” da lista, não entre os “B’s”.

Parte 1: encontro alienígena: Como seria de esperar, tal como em qualquer outra primeira experiência de programação, irá começar por exibir uma expressão no display do micro:bit.

Comece um novo documento TI-Nspire e selecione Adicionar Python > Novo para iniciar um novo programa, com o nome ‘saudacoes’. No Editor Python use [menu] > Mais módulos > BBC micro:bit para selecionar o comando import no topo dos itens do menu:

                  from microbit import *

Dica: Se a mensagem ‘micro:bit não conectado’ alguma vez aparecer, desligue e volte a ligar o micro:bit (reset).

Para exibir uma expressão no display do micro:bit, use o comando:

                        display.show(")

Este comando é encontrado em:

    [menu] > Mais módulos > BBC micro:bit > Display > Methods

O comando é inserido como display.show(valor), mas (valor) é apenas um marcador de posição que terá de ser substituído por algo. Dentro dos parênteses, substitui valor escrevendo a sua expressão entre aspas:

                 “saudações, terráqueos”

 

Quando puser este programa a correr premindo [ctrl] [R] irá ver as letras da sua expressão aparecerem uma de cada vez, no display.

 

Se cometer um erro…volte à página 1.1 para editar o seu programa, e depois volte a correr o programa. Esqueceu-se de colocar o texto que queria exibir entre aspas?

Um melhor método para exibir a expressão é:

                   display.scroll(“saudações, terráqueos”)

que também pode ser encontrado em

    [menu] > Mais módulos > BBC micro:bit > Display > Methods

 

Para completar o comando .scroll( ) pode copiar/colar a expressão a partir do comando .show.

 

Transforme o anterior comando .show() num #comentário (coloque o cursor nessa linha e prime [ctrl] [T]) para desativá-lo e depois coloque novamente o programa a correr.

 

Sim, também pode simplesmente alterar de .show para .scroll digitando.

O método .scroll() faz com que a expressão se mova da direita para a esquerda como uma faixa através do display tornando mais fácil a leitura. Pode controlar a velocidade a que se move adicionando o parâmetro delay= :

display.scroll(“saudações, terráqueos”, delay = 200)

que faz com que haja um atraso de 200 milissegundos (0.2 segundos) na movimentação. Tente também com outros valores de delay.

Parte 2: Seja.Ainda.Minha.Batida.Coraçãoprima [ctrl] [doc] para inserir uma página e selecione Adicionar Python > Novo para adicionar um novo programa Python ao seu documento (o nosso tem o nome ‘batida’).

No Editor Python, vá a [menu] > Mais módulos > BBC micro:bit e selecione o comando import no topo da lista:

from microbit import *

Para exibir o símbolo do coração no display do micro:bit, utilize o comando:

                         display.show(valor)

Este comando encontra-se em:

    [menu] > Mais módulos > BBC micro:bit > Display > Methods

Entre os parênteses substitui “valor” selecionando:

                              Image.HEART

A partir de

[menu] > Mais módulos > BBC micro:bit > Display > Images > Set 1> Heart

Corra o programa (prime [ctrl] [R]) para ver o ícone do coração exibido na grelha 5x5 LED do micro:bit. Esta exibição mantém-se até que outra ocupe o seu lugar, mesmo depois do programa terminar.

Volte ao editor do programa na página anterior e adicione outro comando de exibição para mostrar o coração pequeno:

display.show(Image.HEART_SMALL)

Pode encontrar esta imagem no mesmo menu de Imagens:

[menu] > Mais módulos > BBC micro:bit > Display > Images > Set

Dica: Também pode copiar/colar o primeiro comando de exibição e editar (digita _SMALL). É necessário que tenha o underscore _ e que esteja em maiúsculas.

Corra o programa outra vez. Irá rapidamente ser exibido o coração maior seguido do mais pequeno, que tem este aspeto

Criar um ciclo: Para fazer com que os dois corações pisquem repetidamente (‘coração a bater’), inclui os dois comandos de exibição num ciclo. Antes dos dois comandos de exibição insira:

while get_key() != ”esc”:

encontrado em [menu] > Mais módulos > BBC micro:bit > Commands

e faça a indentação dos dois comandos de exibição de modo a que estes formem o corpo do ciclo.

 

Dica importante: A Indentação é crucial em programação Python. É assim que o python interpreta blocos de ciclo e blocos condicionais. Se os dois comandos de exibição não tiverem uma indentação com o mesmo número de espaços irás ver um erro de sintaxe. Usa a tecla [espaço] ou a tecla [tab] para fazer a indentação das duas linhas na mesma quantidade. Neste Editor, os espaços de indentação estão indicados com símbolos em forma de losango e cor cinzento claro (◆◆), para ajudar a uma indentação apropriada.

Corra o programa novamente e observe o coração a bater! Prima a tecla [esc] para terminar o programa.

 

Dica: Se alguma vez lhe parecer que o seu programa está encravado num ciclo infinito pressione por alguns segundos a tecla [home/on] da sua TI-Nspire para ‘interromper’ o programa. Isto pode acontecer se utilizar while True: a partir do menu de comandos de forma não apropriada. Nestas lições evita-se esse tipo de estrutura.

O menu de Comandos do micro:bit contém alguns comandos python úteis que também podem ser encontrados noutros menus. O módulo do micro:bit importa estes comandos python para si.

 

Pode ver estes e quaisquer outros comandos python a partir de outros menus. Não está limitado a utilizar apenas o menu BBC micro:bit mas pode ter de fornecer os comandos import apropriados.

Para controlar a velocidade com que o coração bate, adicione dois comandos sleep(), um a seguir a cada comando de exibição:

sleep(1000) significa um atraso de 1000 milissegundos (1 segundo).

Também pode ser encontrado em [menu] > Mais módulos > BBC micro:bit > Commands

 

Dica: Atenção à indentação!

Extensão: Tente ‘Criar Caras’. Para o programa use uma estrutura semelhante à do ‘Coração a bater’ mas utilize as imagens de caras encontradas no Set 1 em vez das imagens dos corações.

Nesta lição irá aprender a usar os botões e gestos do micro:bit para conseguir criar um programa que permita simular o lançamento de um dado, registando os valores numa lista que será transferida para um gráfico.
Esta lição tem duas partes:

• Parte 1: Investigar os botões e gestos
• Parte 2: Usar um botão ou um gesto para gerar um conjunto de dados

Objetivos :

• Ler e processar as teclas A e B no micro:bit
• Observar a diferença entre .was e .is
• Transferir os dados do python para a TI-Nspire
• Avaliar os dados recolhidos do micro:bit
• Utilizar gestos para controlar o display

O micro:bit tem dois botões, A e B, em cada lado do visor. O módulo python micro:bit tem dois métodos semelhantes para ler os botões e depois executar tarefas com base nesses botões. Primeiro testará os métodos e depois escreverá um programa que permita recolher dados e analisá-los noutro local na TI-Nspire CX II.

 

Há também um acelerómetro/compasso de 3 eixos no verso do micro:bit e métodos para interpretar o seu movimento e orientação.

Parte 1: Investigar os Gestos e Botões

Crie um programa python num novo documento.

Pressione a tecla [home] e selecione Novo, e depois Adicionar Python >Novo…

O nome que demos ao programa foi botoes_gestos.

Do  [menu] > Mais módulos > BBC micro:bit selecione o comando import no topo da lista:

 from microbit import *

Adicione o ciclo while:

            while get_key()! = ’esc’:

a partir de

       [menu] > Mais módulos > BBC micro:bit > Commands

 

Quase todos os teus programas micro:bit serão designados desta forma

Para testar o botão A, adicione uma estrutura if:

             ◆◆if button_a.was_pressed():

         ◆◆◆◆print("Botão A")

if fica identado por fazer parte do ciclo while e print( ) fica ainda mais identado por fazer parte do bloco if. Nota que a identação apropriada é muito importante em python. Uma identação errada provoca erros de sintaxe ou de execução não esperada do código. Note que os losangos cinzentos (◆◆) indicam o espaço de identação.

if  pode ser encontrado em [menu] > Planos integrados > Controlo.

A condição button_a.was_pressed() pode ser encontrada em

[menu] > Mais módulos> BBC micro:bit > Buttons and Logo Touch

print( ) encontra-se em [menu] > Planos integrados > I/O

Escreva “Botão A” dentro da função print( ).

Nota: is_pressed() será discutido posteriormente.

Está pronto para testar o programa. Prime [ctrl] [R] para executar o programa. Parece que nada está a acontecer. Prima e solta o botão A no micro:bit. Podes verificar a mensagem 'Botão A' no ecrã da calculadora. Cada vez que premir o botão, o texto irá aparecer como é representado na imagem.

 

Prima [esc] e volta para o editor Python.

Adicione outro comando if para verificar o botão B utilizando a condição button_b.is pressed(). Note que ‘IS’ é diferente de ‘WAS’. Brevemente irá perceber a diferença.

             ◆◆if button_b.is_pressed():

         ◆◆◆◆print("Botão B")

 

Dica: novamente, preste atenção às identações!

Corra o programa novamente (prime [ctrl] [R]).

Experimente os botões A e B.

Prima cada botão e prima-e-mantenha-premido cada botão.

Poderá ver a mensagem ‘Botão B’ exibida repetidamente enquanto este botão estiver a ser premido, mas não verás a mensagem ‘Botão A’. Existe uma diferença entre .was_pressed() (que precisa que solte o botão para que ocorra o reset) e .is_pressed(), que apenas verifica se o botão se encontra premido no momento exato em que o comando é processado.

 

Nota: se carregar no botão B muito rapidamente, o programa poderá não exibir a mensagem “Botão B”, visto que o botão não se encontra premido no momento exato em que o comando if é processado.

Introduzindo gestos. O micro:bit tem um acelerómetro eletrónico que pode medir forças de aceleração em três direções diferentes (um acelerómetro de 3 eixos ou 3D).Além de fornecer valores numéricos para a aceleração em cada direção (ver imagem), o micro:bit também fornece 'gestos' simples e fáceis de compreender, tais como 'face para cima' e 'face para baixo' que se baseiam nesses valores direcionais.

 

Esta lição explora estes gestos e demonstra como utilizá-los para programar a tua TI-Nspire CX II com o micro:bit.

1. Recolha o valor do gesto do micro:bit e armazene-o na variável g:

           ◆◆g = accelerometer.current_gesture()

Dica: novamente, preste atenção às indentações!

Escreve ◆◆g =       e depois

Encontre accelerometer.current_gesture() em

               [menu] > Mais módulos > BBC micro:bit > Sensors > Gestures >

 

Por fim, exiba o valor de g:

           ◆◆print(g)

 

Nota: print( ) encontra-se em [menu] > Built ins > I/O

 

Note que estas duas linhas de commando estão identadas, um par apenas para ser parte do ciclo while mas não parte do commando if abaixo. Lembre que a identação de cada linha determina o significado, pelo que ATENÇÂO!

Execute o programa e observe o visor da calculadora para os vários valores, enquanto movimenta o micro:bit. Vire o micro:bit, equilibre-o em cada extremidade, abane, chocalhe, e role-o. Encontra representado na imagem um exemplo.

 

Alguns dos gestos disponíveis são: face up, face down, up, down, left, right, shake. Estes são devolvidos como valores string. Consegue ver todos os gestos no seu ecrã?

#comentário os últimos dois comandos de gestos (use [ctrl] [T] para adicionar um #comentário numa linha), como é demonstrado na figura e adicione esta nova função de gesto a partir do mesmo menu:

  ◆◆if accelerometer.was_gesture(“face down”):

  ◆◆◆◆print(“face para baixo”)

Os métodos dos gestos e as suas “strings” encontram-se em:

 [menu] > Mais módulos > BBC micro:bit > Sensors > Gestures

 

Sim, pode simplesmente escrever as strings dos gestos mas no método .was_gesture() deve corresponder exatamente ao item do menu.

 

Quando correr este programa, irá reparar numa mudança no output:

      .current_gesture() exibe constantemente o gesto.

      .was_gesture() apenas exibe quando o gesto muda.

Botões e gestos são duas formas de obter input do micro:bit e produzir resultados no ecrã da TI-Nspire CX II ou do micro:bit... ou ambos. A parte seguinte desta lição tem como objetivo criar uma atividade que produz um conjunto de dados utilizando o micro:bit para uma avaliação aprofundada posterior, no ecrã TI-Nspire CX II.

Parte 2: Vamos lançar um dado (um cubo numerado de 1 a 6, com um valor em cada face). Quando o botão A é premido, um número inteiro aleatório entre 1 e 6 é atribuído a uma variável. Pode usar o botão A, o B ou um gesto à sua escolha.

Exibe o valor apenas no micro:bit. Tente fazê-lo antes de passar ao passo seguinte. Utilizaremos o programa atual e adicionaremos linhas de código para simular o lançamento do dado.

 

Consegue determinar o número de pintas na face inferior do dado apresentado na fotografia?

Adicione os dois comandos realçados, tal como representado na imagem:

    from random import * e randint() podem ser ambos encontrados em

[menu] > Aleatório

 

O resto do comando ◆◆◆◆dado = randint(1, 6) é escrito manualmente e cuidadosamente indentado porque faz parte do bloco if button_a…

 

Novamente, cuidado com as indentações.

Depois do valor do dado ser determinado, adicione o comando:

                             display.show(dado)

para exibir o valor do dado no display do micro:bit.

 

Execute o programa novamente. Quando prime o botão A, pode observar a mensagem 'Botão A' no ecrã e o número no visor do micro:bit muda... mas nem sempre! Por vezes o número aleatório selecionado é o mesmo que o último número. Cada premir do botão é um 'evento independente'.

Recolha de dados: Lançar todos estes dados com o premir de um botão é agradável mas para prosseguir o estudo seria interessante armazenar esses valores de modo a possibilitar posterior análise. Qual é a face do dado que sai mais frequentemente? Qual é a média? E por ai fora…

 

Adicione comandos ao programa para:

• Criar uma lista em branco
• Adicionar (.append) o valor do dado à lista
• Armazenar a lista do python para a TI-Nspire CX II

Cada uma destas tarefas pode ser descrita sob a forma de comandos localizados em lugares particulares no programa. Tenta sozinho antes de passares ao próximo passo.

A lista em branco deve ser criada no início do programa:

           lançamentos = [ ]

Os parêntesis retos encontram-se no teclado e em [menu] > Planos integrados > Listas

 

Depois de definido valor do dado, este é adicionado à lista:

lançamentos.append(dado)

.append() pode ser encontrado em [menu] > Planos integrados > Listas

 

No final do programa, a lista definitiva é guardada numa lista TI-Nspire:

           store_list(“lançamentos”, lançamentos)

       a função store_list encontra-se em [menu] >BBC micro:bit >Commands

 

Nota: os dois comentários foram removidos de modo a que todo o código possa caber no ecrã. Podes deixar esses comentários no programa.

Quando executar o programa, pressione o botão A várias vezes, depois prima [esc] para terminar o programa. O seu programa python tem uma lista chamada ‘lançamentos’ e agora a sua TI-Nspire também possui uma lista chamada ‘lançamentos’. Estas constituem duas listas separadas.

 

Prima [ctrl]-[doc] ou [ctrl]-[I] para inserir uma nova página e selecione a aplicação de Dados & Estatística. Um conjunto de pontos encontra-se disperso no ecrã. Clique na mensagem ‘Clicar para adicionar variável’ no fundo do ecrã e selecione a lista lançamentos. Consegue ver o ecrã à direita? Cada ponto corresponde a um lançamento do dado. Que informação consegue retirar do gráfico? É capaz de transformar o gráfico de pontos num histograma? Dica: observe o [menu].

 

Podemos modificar o programa de diversas formas; por exemplo: mostrar (print) o número de lançamentos executados, à medida que estes vão sendo simulados.

 

Nota: O botão B e o gesto não têm efeito sobre o dado. Tente modificar o código de modo a que o dado seja lançado apenas quando “agitar” o micro:bit.

 

Lembre-se de gravar o documento!

Extensão:

• print(“terminado.”) no final do programa para saber que este terminou.

Direcione-se para a aplicação Shell e prima [ctrl] [4] para combinar a página Shell com a aplicação de Dados & Estatística, tal como é demonstrado na figura.

 

Executa o programa premindo [ctrl] [R] no Shell. Pressiona o botão A no micro:bit para dar início aos lançamentos do dado e observa o gráfico de pontos!

 

O gráfico irá exibir a mensagem  ‘No numeric data’ inicialmente, porque a lista de lançamentos (lançamentos) foi limpa pelo programa, mas não se preocupes: se premir o botão A inicia a marcação dos dados.

Em vez de exibir apenas a mensagem ‘Botão A’ com cada premir do botão, pode criar um print  da lista de lançamentos. Onde irá incluir o comentário print(lançamentos) no seu código?

Nesta lição, deverá monitorizar o sensor de luminosidade do micro:bit e organizar os dados numa lista TI-Nspire para posterior análise.

Objetivos:

• Ler e exibir o sensor de brilho no micro:bit
• Transferir dados do python para a TI-Nspire CX II
• Analisar os dados recolhidos do micro:bit

O micro:bit é capaz de ler o nível de luminosidade ambiente usando os display LEDs. Sim, os display LEDs  também podem ser usados como um dispositivo de entrada!

Iniciar um programa python num novo documento.

Pressionar o botão [home] e selecionar Novo > Adicionar Python >Novo…

Demos ao programa o nome de brilho.

 

Para verificar os valores que o sensor de luz consegue detetar, escreva o programa abaixo usando os menus do BBC micro:bit:

    from microbit import *

 

    while get_key() != "esc":

    ◆◆brilho = display.read_light_level()

    ◆◆print("brilho = ",brilho)

 

Encontra var= .read_light_level() no [menu] > BBC micro:bit >Sensors ; bright  será o nome da variável que escreverá.

 

Relembrar: [menu] > Mais módulos > BBC micro:bit > Commands> while get_key() != "esc":

 

Não se esqueça de identar as duas últimas linhas de código, pois assim fazem parte do corpo do ciclo while.

Corra o programa e aponte o ecrã do micro:bit para a fonte de luz. O que for exibido no ecrã não é relevante. Aproxime e afaste o micro:bit e observe a variação dos valores no ecrã da TI-Nspire CX II. Deverá observar valores entre 0 e 255.

Como seria de esperar, quanto mais longe o micro:bit se encontra da fonte de luz, menor será o nível de luminosidade. Agora vai adicionar código ao programa, de modo que este possa recolher os dados relativos ao nível de luz e a criar um gráfico de dispersão luz vs. tempo.Pressione [esc] para terminar o programa e voltar ao Editor.

Crie duas listas vazias antes do ciclo while:

      tempos = [ ]

      brilhos = [ ]

Encontre os parênteses retos no teclado [ctrl] [left parenthesis] ou no menu [menu] > Planos integrados > Listas

 

Antes do ciclo while, adicione uma linha para iniciar um contador de tempo (t) em 0:

      t = 0

 

Evite usar a palavra ‘tempo’ como variável porque já existe um modulo de tempo. Além disso, é boa prática pluralizar os nomes das listas visto que estas podem conter vários valores.

No corpo do ciclo, depois da linha de código print, adicione uma linha de código de modo a incrementar a variável t. Utilizaremos um segundo como intervalo de tempo entre leituras do nível de luminosidade, ou seja:

         ◆◆t = t + 1

Adicione (append) os valores brilho e t às suas respetivas listas, utilizando os códigos:

        ◆◆times.append(t)

        ◆◆brights.append(brilho)

 

.append( ) pode ser encontrado em [menu] > Planos integrados > Listas

 

Estes códigos adicionam o valor atual de luminosidade e o valor t (tempo) às listas.

De modo a controlar o intervalo de tempo da amostragem, adicione:

        ◆◆sleep(1000)

a seguir aos dois comandos .append. Este commando pausa a recolha de dados durante um segundo entre amostras. sleep( ) pode ser encontrado em:

                [menu] > BBC micro:bit > Commands

 

É importante lembrar que quando usamos o micro:bit, sleep( ) utiliza milisegundos como argumento. Esta amostragem ocorre uma vez por segundo.

Depois do corpo do ciclo (não se identa mais!), armazene (store) as duas listas de python em duas listas TI-Nspire, utilizando os mesmos nomes em ambos os ambientes de trabalho.

 

Comece no início de uma nova linha (sem identação!).

Encontra store_list() em [menu] > BBC micro:bit > Commands. São necessários dois argumentos: o “nome da lista TI-Nspire” entre aspas e o nome da lista python, sem aspas.

 

Neste programa, as listas python são armazenadas sob a forma de listas TI-Nspire imediatamente antes do programa terminar, quando pressionas [esc] para sair do ciclo.

Corra o programa. Comece com o micro:bit numa posição próxima da fonte de luz. Uma lâmpada ou a lanterna de um smartphone funcionam bem. Lenta mas firmemente, afaste o micro:bit da fonte a uma velocidade constante, até que a luminosidade registada apresente um valor inferior a 10.

Pressione [esc] para terminar o programa.

 

Repita o processo até sentir que tem um “bom” conjunto de dados.

 

Dica: A lanterna de um smartphone funciona lindamente!

Quando o programa terminar, adicione uma página ao documento pressionando [ctrl] [doc]. Selecione ‘Adicionar Dados e Estatística’. Deverá ver uma página semelhante à representada na imagem. Uma das nossas listas aparece sob a forma de dispersão. Agora, ten de organizar o gráfico…

Clique no espaço ‘Clicar para adicionar variável’ no fundo do ecrã e selecione a lista tempos. Esta é a variável independente.

 

Clique no espaço ‘Clica para adicionar variável’ no lado esquerdo do ecrã e selecione a lista brilhos. Esta é a variável dependente. O gráfico da dispersão deverá aparecer como na figura.

 

Poderá ter de correr o programa várias vezes de modo a obter uma “boa” curva como a apresentada na figura. Poderá ser também necessário ajustar a janela para dados diferentes.

 

Poderá ser ainda necessário ajustar o intervalo de tempo entre amostras, assegurando sempre que editas o argumento da variável sleep(1000 ) e o valor do contador. (t = t + 1).

 

Em que é que repara?

• Que padrão observa? Que modelo matemático se adequa ao comportamento físico?
• Utilize as ferramentas de análise de dados da TI-Nspire para determinar um bom modelo matemático para o seu conjunto de dados.

Nesta Apliacação, deverá escrever um programa que permita recolher dados utilizando o micro:bit e executar o programa enquanto observa um gráfico de barras a crescer numa página em separado da TI-Nspire

Objetivos :

• Escrever um programa para recolha de dados no micro:bit
• Criar um gráfico dinâmico em Dados e Estatística

Este projeto requer uma compilação de todas as aptidões de micro:bit adquiridas nas últimas três atividades: escrever um programa que utilize um gesto, como “agitar” (ou o pressionar de uma tecla) para recolher dados, armazená-los numa lista sob a forma de variável TI-Nspire e…

… criar uma página TI-Nspire que:

• Corra o programa python num lado do ecrã (python Shell) e
• Exiba um gráfico de pontos (ou histograma) dos dados recolhidos, em simultâneo com o funcionamento do programa python (utilizando a aplicação Dados e Estatística).

Comece o seu programa micro:bit com os imports habituais, incluindo o módulo random e cria uma lista vazia com o nome somas:

                                somas = [ ]

Armazene, imediatamente, a lista numa variável TI-Nspire (com o mesmo nome).

                             store_list(“somas”, somas)

de modo a que a lista TI-Nspire se encontre também vazia.

 

print( ) algumas instruções para o utilizador, antes do ciclo começar. Vamos usar o gesto “agitar” para lançar os dados.

No corpo do ciclo while, use o gesto para

• Lançar dois dados(gerar dois inteiros aleatórios)
• Adicionar os valores
• Adicionar a soma à lista somas
• Exibir os valores dos dois dados, a sua soma e o número do lançamento no ecrã da TI-Nspire. Dica: len(somas) é o número do lançamento.
• Exibir ambos os valores do dado no display do micro:bit
• Armazenar a lista numa variável da TI-Nspire

Tente agora.

1. Para lançar o dado, use um gesto ou o prima uma tecla:

      ◆◆if accelerometer.was_gesture("shake"):

    ◆◆◆◆display.clear()

    ◆◆◆◆l1 = randint(1,6)

    ◆◆◆◆l2 = randint(1,6)

 

Tome atenção às identações.

Adicione-os e anexe (.append) a soma à lista sums:

    sum = l1 + l2

    sums.append(soma)

Exiba os dados no display do micro:bit. Lembre-se que os dados podem ter o mesmo valor e como tal, é fundamental garantir que ambos aparecem.

    display.clear()

   display.show(l1)

   sleep(250)

   display.clear()

   display.show(l2)

   sleep(250)

 

Talvez prefira utilizar um intervalo mais longo no comando sleep( ). Se tiver escrito o código de forma correta e na sequência apropriada, tente correr o programa e agitar o micro:bit. Deverá ver dois valores exibidos no micro:bit.

Adicione código para exibir o dado, as somas e o número de lançamentos no ecrã da TI-Nspire. Para tal, podemos utilizar um simples comando print():

             ◆◆◆◆print (l1, "+", l2,"=",soma,", ","nexp =", len(somas))

             Resultando nas linhas demonstradas na imagem.

             Cuidado com a identação!

Armazene a lista python sums numa lista TI-Nspire com o mesmo nome:

 

     ◆◆◆◆store_list(“somas”, somas)

 

O comando store_list( ) encontra-se situado profundamente nos blocos while e if, de modo a que a lista TI-Nspire seja atualizada de cada vez que um novo par de dados é lançado.

Quando estiver satisfeito com o funcionamento adequado do programa, encontra-se preparado para conectar o programa python às capacidades gráficas da TI-Nspire. Corra o programa e gere 50 lançamentos. Pressione [esc] para terminar o programa.

 

Na python Shell (a seguir a >>>) pressione [ctrl] [doc] ou [ctrl] [I] para inserir uma página. Selecione a aplicação Dados e Estatistica. Deverá observar um ecrã semelhante àquele apresentado na imagem à direita. Os dados da soma encontram-se dispersos pelo ecrã.

Clique em ‘Clique para adicionar uma variável’ no fundo do ecrã e selecione a lista das variáveis soma (sums). Os dados, previamente dispersos pelo ecrã, encontram-se agora organizados segundo o eixo dos xx, de acordo com o seu valor. A janela encontra-se ajustada ao conjunto de dados analisados. Este é o Gráfico de Pontos (Dot Plot).

Volte para a página da aplicação python Shell ([ctrl] [leftarrow]) e pressione [ctrl] [4] para a ‘agrupar’  com a aplicação de Dados & Estatística, criando uma página de ecrã dividido, com o python Shell à esquerda e os Dados e Estatística à direita.

O Shell foi ‘re-iniciado’ e como tal, pressionando [ctrl] [R] não irá correr novamente o programa. Volte para o editor python e pressione [ctrl] [R] para correr o programa. Este corre no meio-ecrã Shell, como se encontra representado na figura. À direita aparece a mensagem ‘<sem dados numéricos’ porque o programa armazena uma lista vazia automaticamente.

 

Á medida que vai recolhendo dados (agitar o micro:bit para lançar o dado), os valores das somas  aparecem como pontos na aplicação Dados e Estatistica, à direita.

 

Pressionando [esc] terminará o programa e pode fazer muitas coisas com a análide de dados do TI-Nspire.

 

Agora, pressionando [ctrl] [R] novamente (no python Shell) irá correr novamente o programa.

 

Dica: para limpar o Shell no início de cada recolha de dados adiciona o comando::

              clear_history()

   encontrado no [menu] > Mais módulos > BBC micro:bit > Commands

   no início do programa.

 

Divirta-se e não se esqueça de gravar o documento!

 

Nesta lição, vai instalar o módulo Turtle na calculadora e escrever os primeiros programas para desenhar alguns polígonos, utilizando instruções que permitam à tartaruga fazer movimentos.

Objetivos:

• Instalar o módulo Python
• Desenhar e pintar polígonos

Introdução 1

Antes de começar, certifique-se de que a sua TI-Nspire CX II-T tem o Sistema Operativo atualizado.

De seguida, caso não tenha o módulo Turtle instalado, deve aceder à página web https://education.ti.com/pt/product-resources/turtle-module/nspire-python para obter uma pasta compactada, onde encontra o módulo e ainda um guia de iniciação.

Introdução 2
Com o módulo Turtle instalado pode agora incluir os respetivos comandos em linhas de código num programa em Python.

Para que os comandos tenham efeito, deve começar por importar a biblioteca de Turtle para a primeira linha do programa.

Prima [Menu] > Mais módulos > Turtle Graphics > from turtle import*

Surge a instrução from turtle import*, mas também, separado por ponto e vírgula (;), a instrução t=Turtle() na linha de código, a qual cria o objeto Turtle com o nome t.

NOTA: A utilização do ponto e vírgula (;) é a forma como o Python permite que se escrevam duas instruções na mesma linha.

Introdução 3
Voltando ao [Menu], a Mais módulos e depois novamente a Turtle Graphics, encontra oito submenus (2 … 8): Move, Draw, Pen control, Settings, Tell Turtle’s state, Colors, Filling e Commands.

Cada submenu contém funções específicas da tartaruga (e outras), as quais começam com a variável do objeto t, que é o nome padrão da tartaruga (turtle). O nome pode ser alterado e pode também ter-se várias tartarugas no mesmo programa, devendo o utilizador fazer as escolhas que entender.

As funcionalidades do submenu Move podem observar-se na figura. Poderá observar as restantes funcionalidades submenu a submenu.

Um quadrado – o código

Para fazer com que a tartaruga desenhe um quadrado, escreva um ciclo de repetição com apenas duas instruções:

for i in range(4):
t.forward(50)# pixels
t.left(90)# graus

Um quadrado – a execução do programa

Depois de introduzir o código, execute o programa (CTRL + R) para perceber se a tartaruga realmente faz um quadrado.

A tartaruga começa na origem, virada para a direita. O valor 50, em forward, refere-se ao número de pixels no ecrã. As linhas de grelha estão separadas por 25 pixels, como se pode observar na legenda no canto inferior esquerdo do ecrã. O valor 90, em left (rotação no sentido positivo), representa 90º.

No final, a tartaruga regressa à origem e fica voltada para a direita. O desenho (gráfico) permanece no ecrã até ser premida uma tecla.

Um polígono regular com n lados – o desenho

Modifique o programa que permitiu desenhar o quadrado para permitir que o utilizador introduza o número de lados para que a tartaruga desenhe um polígono regular com esse número de lados. Utilize, antes do ciclo de repetição, a instrução:

n=int(input(“Quantos lados? “))

e altere o código do ciclo de repetição.

NOTA: Um pouco mais de conhecimento matemático será necessário para decidir qual o ângulo de rotação, que passará a ser a divisão de 360º por n. Para desenhar o heptágono da figura o ângulo é 360º/7.

Um polígono regular com n lados – o código

Um programa para desenhar o heptágono observado anteriormente ou outro polígono regular à escolha, em função do número de lados, pode ser o que se observa na figura ao lado.

Coloque a instrução t=Turtle() após a linha de código para introdução do número de lados para que a pergunta seja feita antes de surgir o ecrã do desenho.

Para alterar a velocidade da tartaruga, utilize t.speed(0), instrução que pode encontrar no submenu Settings (Menu > Mais módulos > Turtle Graphics > Settings). O argumento entre parênteses é um valor entre 0 a 10, sendo 0 o que corresponde ao movimento mais rápido.

NOTA: Faça algumas experiências com outros valores de n, de velocidade e de medida do lado do polígono.

Colorir o polígono – introdução

Há dois métodos para atribuir cor a uma figura:

t.pencolor(r,g,b)  - no subemu Pen control

t.fillcolor(r,g,b)  - no submenu Filling

O terno (r,g,b) corresponde ao código RGB da cor pretendida.

t.pencolor permite colorir linhas, nesta caso os lados do polígono. Se a instrução estiver no ciclo de repetição e o código RGB for automaticamente alterado, pode ter um lado de cada cor.

t.fillcolor permite preencher a figura com a cor do código RGB considerado.

Um pentágono vermelho

Para obter um pentágono com o interior vermelho, antes de o desenhar tem de escolher a cor, com a instrução t.fillcolor(255,0,0) do submenu Filling. Depois, tem de dar ordem para início do preenchimento com a instrução t.begin_fill(), do mesmo submenu.

Durante o ciclo de repetição, o sistema guarda a lista de vértices “visitados”.

No final, para que se observe o polígono com o interior preenchido tem de colocar a instrução t.end_fill().

Arte com polígonos I

Modifique o programa para fazer polígonos de forma aleatória, seja em relação ao número de lados, à cor ou ao local de início do desenho.

• Utilize t.hideturtle() e t.hidegrid() para melhorar a aparência e a velocidade.
• Utilize wille get_key()!=”esc” no ciclo de repetição principal para parar ao premir a tecla “esc”.
• Utilize t.penup(), t.goto(,), t.setheading() e t.pendown() para colocar a tartaruga num ponto de partida do ecrã aleatório, virada numa direção aleatória, para um comprimento aleatório do lado do polígono.

NOTA: O ecrã da tartaruga tem um número de pixels que varia de -159 a 159 na horizontal e de -106 a 106 na vertical e não há problema se sair fora do ecrã. Pode usar qualquer ângulo, em graus, para rotação.

Arte com polígono II

Estas linhas de código produzem algo ainda um pouco monótono, como pode observar na imagem.

Modifique alguma coisa para tornar o quadro multicolor!

Nesta lição, vai continuar a descobrir o módulo Turtle, utilizando as opções desenho e as opções de movimento.

Objectifs :

• Desenhar um triângulo isósceles e colorir o interior
• Colorir um círculo
• Integrar estes dois objetos para fazer um desenho

Como desenhar a figura ao lado utilizando um programa em Python e o módulo Turtle?

Parece bastante simples. Mas será realmente simples?

Observe que a figura é constituída por:

• um círculo amarelo centrado no ecrã
• um conjunto de triângulos isósceles iguais colocados à volta do círculo.

Para desenhar o sol importa perceber a construção de cada elemento em separado: o círculo e o triângulo.

Desenhar um triângulo isósceles 1

Vejamos as etapas a seguir para construirmos um triângulo isósceles:

• Inicie um novo programa num editor de Python e nomeie-o “Triangulo”.
• Importe a biblioteca de Turtle e ainda a biblioteca de funções matemáticas (math) para os cálculos trigonométricos.
• Crie a variável c, correspondente à medida da base do triângulo com 60 pixéis (c=60).
• Crie a variável b, exprimindo em radianos um ângulo de 70º.
• Crie a variável h, medida de cada um dos lados iguais.

Desenhar um triângulo isósceles 2

Mais algumas configurações para o nosso triângulo:

• Poderá fixar a velocidade da tartaruga com t.speed(), escolhendo como argumento um número natural ente 0 e10.
• No menu 8: Filling pode escolher a cor no sistema RGB para colorir o interior do polígono.
  
  Nota: Há, neste sistema, tantas cores quantos os códigos que se podem formar com um terno em que o primeiro elemento é a intensidade de vermelho, de 0 a 255, e cada um dos seguintes, também no mesmo intervalo, respetivamente verde e azul.


• Os comandos t.begin_fill() e t.end_fill() são utilizados para estabelecer os momentos inicial e final do preenchimento do polígono.

Desenhar um triângulo isósceles 3
Continuando a completar o código para o nosso triângulo:

• No menu 2: Move, use os comandos t.forward() e t.left() para completar a construção do triângulo.
• Por uma questão estética esconda a tartaruga com o comando t.hideturtle() localizado no menu 5: Settings.
• Não se esqueça do comando t.done() no final para exibir o desenho no final da execução do programa.

Nota: O triângulo a desenhado podia ter sido simplificado. Foi construído desta forma para serem melhor compreendidos os cálculos, salientando os dois triângulos retângulos e a escolha do ponto de partida.

• Execute o programa e observe o triângulo obtido.
• Faça várias experiências, modificando a cor de fundo e do contorno, as medidas, …

Nota: Para construir o sol com os raios deverás ser capaz de modificar a orientação do triângulo, assim como a sua posição no referencial.

Mudar o sítio do triângulo

• No menu 2: Move, escolha o comando t.goto(x,y). Este comando permite indicar o ponto, através da suas coordenadas (x,y), para onde a tartaruga se deve mover.
• O local da linha de código com este comando é muito importante. Neste exemplo será antes do desenho do triângulo. Coloque t.goto(50,25).
• Execute o programa. Foi realmente feita uma translação para o ponto (50,25), com a desvantagem de ter ficado o rasto dessa mudança, um segmento de reta do ponto (0,0) ao ponto (50,20).

As cores no Turtle

Nota: As cores podem ser escolhidas, também, no menu 7: Colors, para além do uso do código RGB.

Eliminar o rasto do deslocamento

Vejamos como eliminar o segmento que traduz a deslocação do triângulo:

• Para eliminar o segmento de reta definido pelos pontos de coordenadas (0,0) e (50,25), vá ao menu 4: Pen control e utilize os comandos 2: t.penup() e 3: t.pendown().

Nota: Naturalmente, o comando para deslocar a tartaruga deverá ser incluindo entre estes.

• Execute o programa e observe o efeito produzido por estas três linhas de código.

Mudar a orientação do triângulo

• No menu 1: Move, selecione o comando t.setheading(), esta instrução permitirá rodar a seta (cabeça) do triângulo que representa a tartaruga.


• Coloque esta instrução antes dos comandos para desenhar o triângulo

Nota: t.setheading(graus) define a medida do ângulo de rotação da tartaruga, em graus. Se os valores da medida forem positivos, a rotação faz-se no sentido anti-horário e a rotação será no sentido horário para valores negativos. 

• Em comparação com a orientação anterior, o triângulo deve rodar 90º no sentido horário, portanto terá que se inserir a instrução t.setheading(–90).


• Execute de novo o programa e observe o resultado obtido


• Para desenhar o sol raiado, será assim possível criar a coroa de raios.

Os comandos do tipo t.fillcolor(r,g,b), associados a t.begin_fill() e t.end_fill() apenas funcionam para polígonos e não para círculos.

A instrução t.circle() apenas desenha uma circunferência e não o seu interior.

Deverá então ser utilizado o comando t.dot(diâmetro) que se encontra no menu 3: Draw. A ideia subjacente é o desenho de um “ponto” com um determinado diâmetro, definido em pixéis.

O comando t.pencolor(r,g,b) permite a escolha da cor do lápis para desenhar esse ponto.

• Crie um novo programa e designe-o por círculo.
• Escreva os comandos que observa na figura para desenhar um círculo amarelo.
• Teste o programa, executando-o.

Código para o programa do Sol raiado

Vamos terminar este projeto usando os programas anteriores para construir o nosso sol raiado.

• Modifique o programa triangulo e crie agora um programa para desenhar o Sol com os raios à volta.
• A representação geométrica ao lado fornece os nomes das variáveis para utilizar no programa.
• Ao redor do círculo central do Sol temos, a cada 30º, um triângulo isósceles de base c e lado h (medida de cada um dos lados iguais). Estes triângulos são representados numa circunferência de raio r+e.

• Para orientar corretamente cada triângulo que representa cada raio de sol, utilize o comando t.setheading(–90+30*i), em que i é número de incrementos de 30º.
• O programa completo obtém-se com todos os passos que foram observados até aqui nesta lição, e que se encontram na imagem ao lado. Abaixo coloca-se o código relativo à construção dos raios:

O Sol Raiado

Execute o programa, CTRL + R, e veja o produto final do seu projeto.

Nesta terceira lição irá escrever um programa que lhe permita usar o módulo Turtle do TI-Python para ilustrar a resolução de um problema simples de matemática.

Objetivos:

• Resolver um qualquer triângulo
• Desenhar uma representação geométrica

Introdução

O que propomos é resolver um triângulo escaleno utilizando as relações do matemático Al Kashi.

Este resultado é assim designado em homenagem a al-Kâshî, matemático persa do início do século XV.

Estas igualdades são, também, conhecidas por "Lei dos Cossenos", e generalizam o Teorema da Pitágoras para triângulos não retângulos.

O teorema de Al-Kâshî afirma:

sendo [ABC] um qualquer triângulo e ∝ a medida em radianos do
ângulo BAC, então

Para simplificar, tendo em atenção a notação constante na figura ao lado, podemos afirmar que, para cada um dos lados do triângulo, temos as seguintes igualdades:

O problema

Suponha que são conhecidas as medidas dos três lados de um dado triângulo.
Escreva um programa, com recurso ao módulo Turtle do TI-Python, que:

• apresente a representação do triângulo;
• obtenha e apresente as medidas dos ângulos internos, em graus.

A medida do comprimento dos lados será dada em pixéis.

Criar um novo programa em TI-Python
Na aplicação TI-Python:

• crie um novo programa e designe-o por TL3;
• importe, para já, apenas o módulo Matemática;
• crie as variáveis a, b e c correspondentes aos comprimentos, em pixéis, dos lados do triângulo.

Os comprimentos dos lados serão entradas inteiras do nosso programa, conforme podemos observar no ecrã ao lado.

Inserir as instruções para calcular as amplitudes dos ângulos internos

De seguida, usando a “Lei dos cossenos”, escreva as linhas de código para:

• calcular o valor dos cossenos dos ângulosrespetivamente cos_a, cos_b, cos_c.
• calcular, usando a função trigonométrica inversa acos(), os valores das amplitudes dos ângulos internos do triângulo, em graus e arredondados às décimas.

Inserir as instruções para desenhar o triângulo

Nesta etapa irão ser inseridas as linhas de código, do módulo Turtle, que permitam representar geometricamente o triângulo. Para isso, considere que:

• deve, agora, importar o módulo Turtle;
• o desenho do triângulo começará no ponto de coordenadas (-100,-80), em pixéis, isto é, a posição de um dos seus vértices;
• serão usadas as instruções var=t.xcor() e var=t.ycor() para mais facilmente serem inseridas as etiquetas nos vértices do triângulo.
  Estas instruções são usadas para se guardar as coordenadas da tartaruga, num dado momento, e podem ser obtidas pressionando tecla [Menu], depois A: Mais módulos, em seguida, Turtle Graphics e, finalmente, 6: Tell Turtle's state; e 3: var=t.xcor.
• a instrução t.pencolor (0,0,255) é usada para colocar a caneta em azul, usando-se o código RGB. Também pode usar-se a instrução t.pencolor("azul").

Inserir as instruções para colocar as etiquetas com os nomes dos vértices

A última parte desta lição consiste em inserir as instruções que permitem exibir os nomes dos vértices do triângulo, bem como os valores das amplitudes dos seus ângulos internos. Para isso:

• levantar a caneta inserindo a instrução t.penup();
• ativar a cor vermelho da caneta para a escrita, inserindo-se a instrução t.pencolor(“red”);
• colocar o cursor, a tartaruga, junto de cada vértice usando a instrução t.goto(x,y) e as variáveis onde se guardaram as coordenadas;
• tilizar a instrução t.write(“text“) para escrever a designação do vértice;
• utilizar a instrução t.write(Var) para escrever a amplitude do ângulo interno correspondente a cada vértice.

Nota: Note que no Python da TI-Nspire CX II, a instrução t.write() requer que a cor da caneta seja definida antes de cada utilização, pois por defeito ficará preto.

Executar o programa para resolver vários triângulos
Por fim, execute o programa agora criado para resolver triângulos para quaisquer valores de a, b e c, que verifiquem a desigualdade triangular. Por exemplo para:

• a=100, b=150 e c=200


• a=160, b=250 e c=200

Nesta lição de aplicação irá mobilizar os conhecimentos trabalhados nas anteriores lições por forma a construir um programa que lhe permita a conceção de um projeto.

Objetivos:

• Aplicar os conceitos trabalhos nas lições anteriores.
• Construir uma figura complexa com recurso à programação.

Introdução
Nas atividades das três lições anteriores vimos como usar o módulo Turtle, num programa TI-Python, na construção de uma figura geométrica, sendo que foi necessário antecipadamente realizarem-se cálculos matemáticos.

Para melhor perceção do programa usamos, habitualmente, comentários inseridos entre o código, sempre que oportuno, e também procuramos que cada tarefa complexa fosse dividida num certo número de tarefas simples.

Nesta lição iremos construir, geometricamente, uma árvore de Natal, sendo que o nosso programa principal se dividirá nas seguintes funções mais simples:

• desenhar e colorir um triângulo isósceles;
• desenhar o pé da árvore;
• desenhar e colorir uma estrela;
• enfeitar e reluzir a árvore

Criação do projeto
Todos os projetos têm as suas especificidades. Neste, em que utilizaremos o módulo Turtle e mostrará um objeto gráfico, teremos os constrangimentos resultantes do tamanho do ecrã (grelha unitária de 25 pixéis).

As especificidades do projeto são:

• a decoração da árvore, que consiste na colocação de pontos coloridos, usando a instrução t.dot(diâmetro), sendo o tamanho e posição aleatórios;
• ·os pontos coloridos, que devem estar contidos num triângulo isósceles (a árvore);
• a representação anterior será obtida utilizando um software de geometria dinâmica no qual o sistema de coordenadas ortonormais é idêntico à grelha do módulo Turtle, o que facilitará trabalho;
• os pontos de coordenadas (–75, –75); (75, –75) e (0, 75) serão os vértices do triângulo;
• as retas de equação reduzida y = 2x + 75, y = −2x + 75 e y = −75 delimitarão o domínio plano de representação dos pontos coloridos (os enfeites).

Criação do programa
Na aplicação TI-Python:

• abra um novo programa e designe-o por Apps_Arvore;
• prima na tecla [Menu] e importe os módulos de Matemática, Aleatório e Turtle Graphics, necessários para este projeto;
• o módulo Aleatório permitirá obter aleatoriamente as posições e o número de objetos coloridos (enfeites).

Desenho do pé da árvore
Comecemos, então, por construir a função que desenhe o pé da árvore. Assim, coloquemos as instruções em Python para:

• ocultar a tartaruga – t.hideturtle();
• colocar o cursor, sem escrever – t.penup(), na posição inicial (0,– 100) – t.goto(0, –100);
• baixar a caneta para se poder desenhar – t.pendown();
• definir a cor do lápis como castanho, correspondente ao código RGB (165, 42, 42) usando a instrução t.pencolor(165, 42, 42);
• de seguida orientar a tartaruga para cima – t.setheading(90);
• para traçar o pé da forma mais simples e ficar bem visível, escolher a espessura mais grossa do lápis – t.pensize(3);
• desenhar o pé com comprimento de 25 pixéis – t.forward(25).

Todas as instruções anteriores estão disponíveis no módulo Turtle, premindo tecla [Menu], depois a opção A: Mais Módulos, seguido de 7: Turtle Graphics e, por fim, escolhendo a opção pretendida.

Desenhar a estrela do cimo da árvore
Para desenhar a estrela vai ser criada uma função que designaremos por estrela(). Poderemos aqui, se necessário, revisitar o guião da Lição 1, na qual foram desenhamos polígonos regulares.

Nesse caso, necessitaríamos de usar um programa num programa, procedendo-se à sua importação usando-se a instrução from PROGRAMA import* disponível no catálogo.

Neste caso, usaremos um novo programa, realizando as etapas:

• fixar a estrela no topo da árvore no ponto das coordenadas (0, 75) – t.goto(0,75);
• com a instrução t.fillcolor() completar a coloração dos ramos da estrela;
• preencher os ramos com uma tonalidade laranja de código RGB (255,127,0) – t.fillcolor(255,127,0);
• em cada iteração, mover a tartaruga 30 pixéis para a frente e rodar para a direita por 144 graus.
• cada um dos ângulos interiores da estrela será de 36 graus;
• com 5 iterações ficará perfeitamente construída a estrela, usando o ciclo de controlo while.

Desenhar uma dada estrela em função do seu tamanho
Vejamos como construir uma função que permita construir uma estrela sólida de uma dada cor. Dependendo do tempo que pretender disponibilizar ao seu projeto, pode optar por este triplo de estrela no cimo da árvore de Natal ou até como um dos elementos de enfeite. Vejamos as principais etapas do código dessa função que se encontra na imagem ao lado:

• a função terá um argumento, o tamanho da estrela - size, designando-se a função por star(), portanto chamando a função com star(size);

• a estrela será preenchida por uma cor, neste caso cor de laranja cujo código RGB é (225,127,0), usando-se as instruções t.pencolor(225,127,0), para escrever a laranja, e t.fillcolor(255,127,0), para colorir a laranja;
• de seguida usa-se, nos Planos Integrados, o ciclo de controlo For index in range(size), em serão traços dois segmentos consecutivos da estrela;
• repetição 5 vezes das instruções deste ciclo permitirá encerrar o polígono estrela e o preencher na cor pretendida;
• para usar esta função, por fim, fazemos a correr para um tamanho de 30 pixéis – star(30);
• por fim, escondemos a tartaruga – t.hideturtle().

Desenhar a árvore

A tarefas para esta função consiste em construir um triângulo isósceles simples, como já referimos na implementação do projeto.

Todas as medidas (amplitudes dos ângulos, comprimento dos lados, ...) resultam de trabalho preparatório com ambiente de geometria dinâmica.

O triângulo isósceles, a nossa árvore, será preenchido pela cor verdade árvore cujo código RGB é (,121,111) – t.fillcolor(1,121,111).

Desenhar as bolas (enfeites) de Natal
Vamos agora criar a função que nos permitirá desenhar as bolas de enfeites da árvore de Natal, sendo de tamanhos e cores aleatórias. Recordar que para usar as funções aleatórias foi necessário importar, no início do programa, o módulo Aleatório. A função, designada por bolas(), dependerá de um argumento k que define o número de bolas a representar, portanto usaremos bolas(k). Temos ainda que:

• para definir as cores usamos a função randint() que permite gerar inteiros aleatórios, neste caso entre 0 e 255, que definirá a porção de vermelho, R, verde, G, e de azul, B, em cada bola;
• o tamanho da bola, mais propriamente o seu diâmetro, é obtida de forma aleatória com a função aleatória randint(5,10);
• também a posição da bola, através das suas coordenadas em pixéis, são obtidas através da mesma função aleatória randint(), desta feita para valores entre –75 e 75 para a abcissa e –90 e 90 para a ordenada;
• por fim, através de um ciclo de controlo, neste caso If …, é garantida a representação da bola caso as suas coordenadas satisfação as condições que definem o domínio plano que define a árvore.

O programa principal
Estão terminadas todas as funções mais simples em que não dividimos o nosso projeto de construção de uma Árvore de Natal, bastará agora colocar no programa a execução destas funções.

Assim, embora sendo indiferente a ordem com que colocarmos as funções se não usarmos pausas, aqui vamos usar uma ordem especifica e com ligeiras pausas de 1 segundo.

A instrução colocada no final do nosso programa t.done() deixa a imagem exibida. Pressionando-se qualquer tecla desaparecerá a imagem e surgir a linha de entrada do Shell Python com >>>.

No editor do programa no Python pode gravar e verificar o programa usando o atalho CTRL + B, e poderá executá-lo através do atalho CTRL + R. No Shell Python podem também executá-lo com o atalho CTRL + R.