Tutorial TI-83 BASIC

A intenção deste tutorial é de apresentar a programação em TI-83 BASIC. Para a leitura deste tutorial não são necessários quaisquer conhecimentos em programação, embora estes possam facilitar a compreensão do mesmo.

Este tutorial é destinado a utilizadores de calculadoras gráficas TI-83 / TI-83 Plus / TI-83 Plus Silver Edition que queiram aprender programação a partir da linguagem TI-83 BASIC, ou que já tenham conhecimentos de programação e queiram aprender uma nova linguagem.

O tutorial irá conter exemplos de programas para todas as situações apresentadas, para facilitar a compreensão.

Sobre a linguagem

A linguagem TI-83 BASIC é uma linguagem de alto nível, ou seja, aproxima-se mais da linguagem humana, neste caso a inglesa, do que da linguagem máquina. A principal particularidade desta linguagem é que os comandos desta não precisam de ser compilados, apenas são lidos pela calculadora, quando o programa é executado. Por esta razão, os erros que o programa poderá ter só serão detectados pela calculadora quando o respectivo comando for executado.

Esta linguagem só pode ser usada na gama das calculadoras TI-83, mas contém os comandos básicos de qualquer linguagem de programação. Por isso é considerado uma boa linguagem para a iniciação em programação.

As três calculadoras possuem características diferentes. Variam na memória, na existência de memória FLASH, que permite arquivar ficheiros, e na possibilidade de usar letras minúsculas. A tabela seguinte demonstra esses factos para não existirem problemas de compatibilidade entre calculadoras TI-83:

	TI-83	TI-83 Plus	TI-83 Plus SE
Memória RAM	27 KB	24 KB	24 KB
Memória FLASH	Não tem	140 KB	2000 KB
Letras minúsculas	Não permite	Permite	Permite

1 – Aspectos Básicos

1.1 – Criar e editar um programa

Para criar um novo programa:

[PRGM] > [NEW] > 1:Create New

A seguir tens que escolher o nome para o programa. O nome pode ter até 8 caracteres. Depois de escolheres o nome aparece logo o ecrã para editares o teu programa. Podes ver o nome do teu programa em cima e dois pontos, seguidos do cursor, na linha abaixo.

Para editar um programa já criado:

[PRGM] > [EDIT] > Seleccionar o programa a editar

1.2 – Eliminar, arquivar e ver o espaço da memória de programas

Para ver os programas e outros ficheiros em memória na calculadora:

[2nd] > [MEM] > 1:All

Em cima aparece a memória RAM e FLASH disponível. Depois todos os ficheiros que estão na calculadora, com o espaço de memória que ocupam à frente. Os primeiros a aparecer são os programas.

Para eliminar um ficheiro carrega-se na tecla [DEL] e depois confirmar.

Para arquivar um ficheiro carrega-se na tecla [ENTER]. A seguir irá aparecer um asterisco atrás do programa para indicar que está arquivado. Para desarquivar um ficheiro selecciona-se um programa já arquivado e carrega-se na tecla [ENTER]. A seguir o asterisco irá desaparecer.

1.3 – Primeiro programa

Antes de escreveres o teu primeiro programa precisas de algumas informações.

Cada comando tem dois pontos atrás. A calculadora já os cria automaticamente quando é criada uma nova linha de comando. Para criar uma nova linha de comando é só carregar [ENTER] na última linha de comando. Para inserir uma linha comando a meio do programa é preciso carregar [2nd] > [INS] > [ENTER]. Quase todos os comandos encontram-se em [PRGM], quando estamos a editar um programa. Para bloquear o teclado alfa-numérico (letras) carrega-se em [2nd] > [ALPHA].

Agora que já sabes o básico insere as seguintes linhas:

:ClrHome

:Disp “Olá mundo de TI-83”

:Pause

:Stop

ClrHome: [PRGM] > [I/O] > 8:ClrHome

Disp: [PRGM] > [I/O] > 3:Disp

Pause: [PRGM] > [CLT] > 8:Pause

Stop: [PRGM] > [CLT] > F:Stop

Agora vou explicar os comandos passo a passo:

O comando ClrHome limpa o ecrã, colocando o cursor no canto superior esquerdo. O comando Disp permite aparecer uma variável no ecrã. A seguir escreve-se a variável a mostrar. Como é texto tem que estar entre aspas. O comando Pause pára o programa até o jogador carregar [ENTER]. O comando Stop termina o programa, aparecendo no ecrã a mensagem Done.

Para executar o programa:

[PRGM] > [EXEC] > escolher o programa > [ENTER]

2 - Variáveis

As variáveis são um elemento fundamental na programação. São elas que tornam o programa interactivo e funcional. As variáveis armazenam os valores utilizados nos programas. Existem vários tipos de variáveis, consoante o tipo de valor que armazenam.

As variáveis não necessitam de ser declaradas. Basta atribuir-lhes algum valor e estas são criadas automaticamente. No entanto, estas variáveis não são limitadas apenas ao programa que as criou, o que quer dizer que não são apagadas no fim da execução do programa e que podem ser usadas por outros programas.

Existem mais variáveis na calculadora para além das que vão ser referidas, mas não são importantes para a criação de programas.

Como atribuir valores:

(valor)→(variável)

Ex.:

15→A

“SERGIO”→Str1

O símbolo “→” aparece ao carregares na tecla [STO→]

Também se pode atribuir valores de outras variáveis:

(variável A) →(variável B)

Ex.:

5→A

A→B

neste exemplo B vai ficar igual a 5

“DAVID” →Str1

Str1→Str2

neste exemplo Str1 vai ficar igual a “DAVID”

É também possível realizar operações:

(valor A)+(valor B) →(variável)

Ex.:

5*2→A

(6+2)/4→B

E por fim, é possível combinar valores com variáveis:

4→A

3→B

(2+A)*4-B→C

neste exemplo C vai ficar igual a 21

2.1 – Inteiros e reais

Ao contrário da maioria das linguagens de programação, a linguagem TI-83 BASIC apenas tem um tipo de variáveis que pode armazenar valores inteiros ou reais. Essas variáveis já estão predefinidas pela calculadora, o que quer dizer que não se pode criar novas variáveis para além das permitas pela calculadora. As variáveis predefinidas são as letras de A a Z mais o símbolo θ.

Cada variável deste tipo ocupa 18 B de memória, qualquer que seja o seu valor.

Exemplo de um programa que usa este tipo de variáveis:

:ClrHome

:6→A

:2→B

:A+B→C

:Disp C

:A-B→D

:Disp D

:A*B→E

:Disp E

:A/B→F

:Disp F

:Pause

:Stop

Na segunda e terceira linha são atribuídos os valores a A e B. Depois são efectuadas operações que são armazenadas numa variável. Por fim, para cada variável criada é mostrado o seu valor no ecrã, com o comando Disp (variável).

2.2 – Cadeias

Este tipo de variáveis é mais conhecidas pelo termo inglês “String”. As cadeias permitem armazenar cadeias de caracteres, ou seja, texto. Como as variáveis numéricas atrás referidas, as cadeias também estão predefinidas, existindo apenas 10. Estas são identificadas por Str1, Str2, …, Str9, Str0. Para atribuir texto é necessário este estar entre aspas.

O mínimo de espaço ocupado por uma cadeia é de 11B, aumentando este valor com o número de caracteres.

Exemplo de um programa que usa cadeias:

:ClrHome

:”SERGIO” →Str1

:”SANTOS” →Str2

:Output(4,2,Str1)

:Output(4,10,Str2)

:Pause

:Stop

Output(:[PRGM] > [I/O] > 6:Output(

Neste programa são atribuídas duas palavras a duas variáveis (Str1 e Str2). Depois aparece um novo comando – Output(. Este comando permite mostrar texto numa dada posição do ecrã e pode ser escrito de duas maneiras: Output(linha,coluna,”texto”) ou Output(linha,coluna,variável). O valor da linha e coluna é referente ao primeiro carácter do que vai ser mostrado no ecrã. Para ajudar a ter uma ideia, o ecrã da calculadora tem 8 linhas e 16 colunas.

Existe apenas uma operação possível com cadeias, somar, mas com um resultado diferente:

(texto1)+(texto2) →(cadeia)

(cadeia1)+(cadeia2) →(cadeia3)

Ex.:

“ABC” →Str1

“DEF” →Str2

Str1+Str2→Str3

Neste exemplo Str3 irá ser igual a “DEFABC”, em vez de “ABCDEF”.

2.3 – Listas

Este tipo de variáveis permite serem guardados mais do que um valor ao mesmo tempo, sendo todos eles inteiros ou reais. A lista pode guardar os valores que necessitarmos. Para além de existirem 6 listas predefinidas, L1, L2, L3, L4, L5, L6, também se pode criar as nossas listas com um nome até 5 letras ou números. O nome de uma lista tem que ter sempre o símbolo “L” atrás. Este pode ser encontrado em [2nd] > [LIST] > [OPS] > B:L.

Exemplo de um programa que usa uma lista:

:{7,5,10}→L1

:ClrHome

:Disp “Valor 1=”,L1(1)

:Disp “Valor 2=”,L1(2)

:Disp “Valor 3=”,L1(3)

:Pause

Este programa mostra 3 valores contidos numa lista. Para atribuir todos os valores de uma vez a uma lista, insere-se todos os valores dentro de {}, com os valores separados por vírgulas. Para atribuir ou referir apenas uma valor de uma lista usa-se LNOME(x), em que “NOME” é o nome da lista e “x” é a posição que o valor ocupa na lista. Neste programa não aparece o comando Stop para finalizar o programa. Este comando pode ser omitido no final de um programa.

Para dimensionar uma lista usa-se o comando dim(. Por exemplo, redimensionar uma lista para ter apenas três valores seria: 3→dim( L1). Assim, se a lista ainda não existisse, seria criada com três espaços com os valores iguais a zero. Se a lista contém menos de três valores, seriam criados os restantes com valores iguais a zero, mantendo os anteriores. Se a lista contém mais de três valores, os que estão a mais seriam eliminados.

2.4 – Matrizes

As matrizes são listas bidimensionais. Os valores são dispostos por linhas e por colunas. O tamanho de uma matriz pode variar consoante as necessidades, sendo apenas limitado pela memória disponível na máquina. As matrizes já estão predefinidas pela máquina. Existem 10: [A], [B], …, [J]. A sua identificação pode ser encontrada em [2nd]>[MATRX], assim como o resto das funções relacionadas com matrizes.

Exemplo de um programa que usa uma matriz:

:[[1,2][3,4]] →[A]

:ClrHome

:Disp “Linha 1 Col 1=”,[A](1,1)

:Disp “Linha 1 Col 2=”,[A](1,2)

:Disp “Linha 2 Col 1=”,[A](2,1)

:Pause

Os valores que devem aparecer no ecrã são 1,2 e 3 por esta ordem.

Também é possível dimensionar ou redimensionar uma lista da seguinte forma: “{2,2}→dim([A])”. Assim, a matriz passaria a ter duas colunas e duas linhas, respeitando as mesmas regras de uma lista redimensionada.

3 – Ciclos condicionais

Aqui são apresentados os comandos que permitem efectuar diversos comandos, consoante a escolha do programador ou do jogador. Estes são muito importantes em qualquer programa em que existam escolhas ou decisões por tomar quer do programador, como do jogador.

3.1 – Operadores

Antes de avançar para os ciclos condicionais é importante explicar como funcionam os diferentes operadores.

Existem os operadores comparativos ou relacionais, que permitem relacionar dois valores, por exemplo, 5>2. O resultado de uma operação comparativa só pode ser ou verdadeiro ou falso. Assim, se escrevêssemos na calculadora 5>2 o resultado seria 1, ou seja verdadeiro. Se escrevêssemos 2>5 o resultado seria 0, ou seja falso.

O operadores comparativos ou relativos podem ser encontrados em [2nd]>[TEST]. Estes são:

= Igual

≠ Diferente

> Maior que

≥ Maior ou igual que

< Menor que

≤ Menor ou igual que

Existem também os operadores lógicos, que permitem relacionar valores booleanos, ou seja, verdadeiros ou falsos, por exemplo, “Verdadeiro and Falso”. Estes normalmente só são usados conjuntamente com os operadores comparativos, por exemplo, “3=3 and 5≠4”. O resultado de um operador lógico também só pode ser verdadeiro ou falso.

Os operadores lógicos podem ser encontrados em [2nd]>[Test]>[LOGIC]. Estes são:

and – Conjunção (e)

or – Disjunção (ou)

xor – Disjunção exclusiva (ou então)

not( - Negação

A tabuada dos operadores lógicos:

A	B	A and B	A or B	A xor B	not(A)	not(B)
V	V	V	V	F	F	V
V	F	F	V	V	F	V
F	V	F	V	V	V	F
F	F	F	F	F	V	F

3.2 – If

O ciclo condicional mais usado no mundo da programação é o ciclo If. Este permite que se realizem uma série de comandos, se uma condição for verificada, como é exemplificado no seguinte esquema:

:Comando

:If Condição

:Comando (Só executado se a condição for verdadeira)

:Comando

Por exemplo:

:10→A

:If A=10

:Disp “A é igual a zero”

:Pause

O comando If pode ser encontrado carregando no botão [PRGM] enquanto estás no EDIT de um programa. O que o exemplo de programa faz é, se A for igual a 10, como é o caso, o comando Disp “A é igual a zero” é executado. Se, por exemplo, for atribuído outro valor a A diferente a 10, o terceiro comando seria saltado, ficando o programa parado sem nenhuma mensagem no ecrã.

3.3 – If / Then

A partir desta combinação é possível correr um variado número de comandos se a condição for verdadeira, segundo o seguinte esquema:

:Comando

:If Condição

:Then

:Comando (Só executado se a condição for verdadeira)

:End

:Comando

Por exemplo:

:3→B

:If B<5

:Then

:Disp “B é menor que 5”

:7→C

:End

:Pause

O comando Then e End podem ser encontrados em [PRGM]. No exemplo, o quarto e quinto comando só são executados se B for menor que cinco, como é o caso. Os comandos são executados, sendo a condição verdadeira, até ao comando End. Assim o comando Pause será executado nas duas possibilidades. O número de comandos que se podem encontrar entre os comandos Then e End é infinito.

3.4 – If / Then / Else

A partir desta combinação é possível executar uma série de comandos se a condição for verdadeira, e executar outra série de comandos se a condição for falsa, segundo o seguinte esquema:

:Comando

:If Condição

:Then

:Comando (Só executado se a condição for verdadeira)

:Else

:Comando (Só executado se a condição for falsa)

:End

:Comando

Por exemplo:

:12→D

:If D≥10

:Then

:Disp “D é maior ou igual a 10”

:Else

:Disp “D é menor que 10”

:End

:Pause

O comando Else pode ser encontrado em [PRGM]. No exemplo, o quarto coimando será executado e o sexto não, já que D é maior que 10. Se for atribuído um valor menor que 10 a D, o sexto comando será executado e o quarto não. Neste caso nunca podem ser executados os dois comandos. O número de comandos entre os comandos Then e Else, e Else e End são infinitos.

Os ciclos If podem criar estruturas com mais de que um ciclo, como é demonstrado no seguinte esquema:

:If Condição

:Then

:If Condição2

:Comando (do segundo “If”)

:Comando (do primeiro “If”)

:Else

:Comando (do primeiro “If”)

:End

3.5 – IS>(

Este comando é pouco utilizado e praticamente inexistente noutras linguagens. O que este comando faz é acrescentar 1 a uma variável e verificar se esta é maior que um determinado número. Se for o comando seguinte será ignorado, como demonstra o seguinte esquema:

:Comando

:IS>(variável, valor)

:Comando (Só executado se a variável+1 for inferior ou igual ao valor)

:Comando

Por exemplo:

:10→A

:IS>(A,5)

:Disp “Menor ou igual que 5”

:Disp A

:Pause

O comando IS>( pode ser encontrado em [PRGM]. No exemplo, primeiro, foi adicionado 1 a A, passando a ser 11. Depois, como o valor de A (11) era maior que 5 o comando seguinte, o terceiro, foi ignorado. Se o valor atribuído a A fosse, por exemplo, 3, o seu valor final seria 4, e o terceiro comando seria executado.

3.6 – DS<(

Este comando é o oposto do anterior, sendo também muito pouco utilizado noutras linguagens. Este comando subtrai um a uma variável e, se a condição for verificada, o próximo comando será ignorado, como demonstra o seguinte esquema:

:Comando

:IS>(variável, valor)

:Comando (Só executado se a variável+1 for superior ou igual ao valor)

:Comando

Por exemplo:

:10→B

:DS>(B,5)

:Disp “Maior ou igual que 5”

:Disp B

:Pause

O comando DS<( pode ser encontrado em PRGM]. No exemplo, a variável B passará ser 9, já que foi subtraído 1. Depois, como B (9) é maior que 5, o comando seguinte será executado, o terceiro. Se o valor de B fosse inferior a cinco, o comando seguinte seria ignorado.

4 – Ciclos de repetição

Os próximos comandos irão permitir a repetição de um conjunto de comandos, um determinado número de vezes, ou até que uma condição se verifique. Estes são muito importantes para evitar que o código de um programa se torne demasiado extenso e cansativo, e também para criar ciclos muito usados em jogos.

4.1 – For(

O ciclo for está presente na grande maioria das linguagens de programação e é muito utilizado, devido à sua funcionalidade. Neste ciclo é usada uma variável a que é atribuído um valor. Depois são determinados um valor final para a variável e o incremento. O ciclo acaba quando for atingido o valor final. O ciclo é declarado da seguinte maneira:

:For(variável, valor inicial, valor final, incremento)

:Comando

:…

:End

Por exemplo:

:For(A, 1, 10, 1)

:Disp A

:Pause

:End

O comando For( pode ser encontrado em [PRGM]. No exemplo, os comandos entre a instrução For( e End serão repetidos. A cada repetição será adicionado 1 à variável A. Os comandos serão repetidos até A ser igual a 10. No programa irão aparecer os valores que A irá tomar, seguidos do comando Pause, onde é necessário carregar [ENTER].

É possível omitir o incremento. Sempre que isto for feito o incremento predefinido será de 1. Assim, o ciclo For( do exemplo anterior poderia ser escrito da seguinte maneira: For(A, 1, 10), sem nenhuma alteração no resultado do programa.

Também possível criar ciclos For( em que o valor diminuía, sendo preciso apenas alterar o valor do incremento para um valor negativo e determinar o valor final inferior ao inicial.

4.2 – While

Este ciclo repete um conjunto de comandos, se a condição inicial for verificada. Logo, pode acontecer o caso de a condição ser falsa inicialmente, e os comandos nunca serem executados. Um esquema exemplificativo:

:While Condição

:Comando

:…

:End

Por exemplo:

:1→F

:While F<5

:Disp F

:Pause

:F+1→F

:End

O comando While pode ser encontrado em [PRGM]. No exemplo, os comandos entre as instruções While e End serão repetidos até F deixar de ser menor que 5, já que em cada ciclo, F irá ganhar 1.

4.3 – Repeat

Este ciclo é muito parecido com o ciclo While. Mas, enquanto no ciclo While, os comandos poderão nunca ser executados, caso a condição seja falsa desde o início, no ciclo Repeat os comandos serão executados pelo menos uma vez, qualquer que seja o valor da condição. Existe outra diferença já que no ciclo While, os comandos são executados enquanto a condição for verdadeira, e no ciclo Repeat os comandos são executados enquanto a condição for falsa. Assim que esta se tornar verdadeira, o ciclo será terminado. O ciclo Repeat usa a mesma estrutura que o ciclo anterior como demonstra o seguinte esquema:

:While Condição

:Comando

:…

:End

E agora dois programas para demonstrar as diferenças entre os dois ciclos:

:ClrHome

:1→A

:While A=1

:Disp “.”

:End

:ClrHome

:1→A

:Repeat A=1

:Disp “.”

:End

O comando Repeat pode ser encontrado em [PRGM].

No primeiro programa o ciclo será infinito, já que A nunca deixa de ser igual a um (Para terminar o programa carregar em [ON] e escolher 1:Quit). No segundo programa, a condição já é verdadeira, por isso o ciclo só será executado uma vez.

5 – Input/Output

5.1 – Input

Este comando permitir que o utilizador do programa possa introduzir dados que serão utilizados no programa. Esses dados poderão tanto ser números como palavras. O programa para enquanto o utilizador estiver a inserir os dados e só continuará quando este carregar [ENTER]. O comando poderá ser escrito de várias formas. Poderá só ser indicada a variável a perguntar: Input A. Neste caso será introduzido um ponto de exclamação antes. Poderá também ser escrito texto antes: Input “Quantos anos tens?”,B. Neste caso não é adicionado um ponto de exclamação antes. Em vez de A e B poderão aparecer qualquer tipo de variável, sendo as mais utilizadas as numéricas e as cadeias.

Um exemplo de um programa com o comando Input:

:ClrHome

:Input “Qual é o teu nome?”,Str1

:ClrHome

:Disp “Olá,”,Str1

:Pause

O comando Input pode ser encontrado em [PRGM]>[I/O]. No exemplo irá aparecer o texto inserido em Input, a seguir a “Olá,”. Não é necessário colocar um Pause a seguir ao comando Input porque este para o programa automaticamente.

5.2 – Prompt

Este comando, que pode ser encontrado em [PRGM]>[I/O], permite fazer exactamente o mesmo que o anterior, mas apresenta algumas diferenças. Quando é executado o comando Prompt A, no ecrã irá aparecer “A=?” e, quando é perguntada alguma cadeia, o utilizador precisa de meter o texto entre aspas para o programa não dar erro. O comando Prompt não permite o uso de texto antes de ser inserida a variável.

5.3 – DispGraph

Este comando permite apresentar no ecrã o modo gráfico, aparecendo também as equações se alguma delas estiver a ser usada. A execução do programa é continuada logo a seguir à apresentação, não havendo qualquer tipo de pausa. Se for desenhada alguma coisa no modo gráfico, a partir de um comando, este também é apresentado automaticamente no ecrã. O comando pode ser encontrado em [PRGM]>[I/O].

5.4 – DispTable

Este comando permite apresentar no ecrã a tabela que apareceria se carregasse-mos [2nd]>[TABLE]. Ao contrário do comando anterior, este comando para a execução do programa até o utilizador carregar em [ENTER], para este poder visualizar toda a tabela. O comando pode ser encontrado em [PRGM]>[I/O].

5.5 – getKey

Este comando é muito utilizado, especialmente na programação de jogos já que permite descobrir se foi carregada alguma tecla e qual é que foi. Existem diversas maneiras de utilizar este comando, dependendo da informação que se quer obter. A seguir temos vários exemplos:

:ClrHome

:Repeat getKey

:End

:Disp “Uma tecla foi pressionada”

:Pause

O comando getKey pode ser encontrado em [PRGM]>[I/O]. No exemplo, o programa entra no ciclo Repeat que é executado até que getKey seja diferente de zero (diferente de falso (0), ou seja, verdadeiro), ou seja, que seja pressionada uma tecla. Assim que uma tecla for pressionado o ciclo termina, sendo executados os comandos seguintes. Neste exemplo não é possível verificar qual foi a tecla premida pelo utilizador.

:ClrHome

:0→K

:While K=0

:getKey→K

:End

:Disp “Foi carregada a tecla”,K

:Pause

No exemplo, o programa entra num ciclo infinito até que K armazene um valor diferente de zero, o que irá acontecer quando for pressionada alguma tecla já que o valor de getKey é constantemente armazenado em K. Depois, os seguintes comandos serão executados, e o valor armazenado em K será apresentado, que corresponderá à tecla pressionada. Os códigos das teclas da calculadora gráfica TI-83 Plus, e que aplica às restantes, são apresentados no seguinte esquema.

	25
24		26
	34

102

103

104

105

Como demonstra o esquema, o código 11 corresponde à tecla [Y=], o 21 à [2nd] e assim sucessivamente. A tecla [ON] não possui código já que, ao ser pressionada, o programa é abortado.

6 – Labels

6.1 – Lbl / Goto

Estes dois comandos permitem saltar de uma linha de código para outra. O comando Lbl define um local no código do programa, a partir de uma etiqueta. Esta pode ser um número de 0 a 99 e também pode letras ou ser apenas composta por letras, incluindo o símbolo θ. No entanto não pode exceder dois caracteres. Por exemplo, as seguintes etiquetas são válidas: Lbl A, Lbl 77, Lbl X5, Lbl 4F, Lbl CC, Lbl θ9. As seguintes etiquetas não são válidas: Lbl 100, Lbl (1, Lbl A5J.

O comando Goto indica ao programa que deve saltar para uma determinada parte do código. No comando também deve ser definida a etiqueta. Por exemplo: Goto A. Para ser executado este comando é necessário que exista o comando Lbl A no programa ou ocorrerá um erro. O comando poderá estar antes ou depois da instrução Goto. O seguinte programa exemplificará o uso destes dois comandos.

:ClrHome

:Disp “Será efectuado um salto de código”

:Pause

:Goto 1

:Disp “Este texto não irá aparecer”

:Lbl 1

:Disp “Salto efectuado”

:Pause

Os comandos Lbl e Goto podem ser encontrados em [PRGM]>[I/O]. No exemplo, foi efectuado um salto a meio do programa. Assim, todas os comando que estejam entre a instrução Goto 1 e a Lbl 1, não serão executadas. O salto é feito automaticamente sem o utilizador se aperceber.

Através de Labels, também é possível sair a meio de alguns ciclos de repetição, como irá demonstrar o seguinte exemplo:

:ClrHome

:Disp “Verificando…”

:For(A,1,200)

:getkey→W

:If W≠0

:Goto A

:End

:Disp “Não foi pressionada nenhuma tecla”

:Pause

:Stop

:Lbl A

:Disp “Foi pressionada a tecla”,W

:Pause

No exemplo é criado um ciclo for que se irá repetir por 200 vezes. A cada vez será verificado se alguma tecla foi pressionada. Se uma tecla for pressionada durante esse período de tempo, então W ficará diferente de zero, e será efectuado um salto para a etiqueta A, no fim do programa, que irá apresentar o respectivo texto. Se não for pressionada nenhuma tecla, o ciclo irá terminar, e serão executados os comandos até ao comando Stop que irá terminar o programa.

6.2 – Menu

Esta linguagem contém um comando que permite criar menus durante um programa. Este comando combina texto com labels. É necessário indicar o título do menu, o texto de cada uma das opções e a label a que esta é relativa. Um menu pode apresentar até sete opções e o texto relativo a cada uma, não deverá ser maior do que 14 caracteres. O programa é parado enquanto escolhida a opção. O seguinte esquema demonstra a utilização do comando Menu(:

:Menu(“Título”,”Opção 1”,1,”Opção 2”,2)

:Label 1

:Comando

:…

:Label 2

:Comando

:…

Por exemplo:

:ClrHome

:7→A

:Disp ”Queres saber qual é o valor de A?”

:Pause

:Menu(“Queres?”,”Sim”,A1,”Não”,B2)

:Lbl A1

:Disp “O valor de A é”,A

:Pause

:Lbl B2

O comando Menu( pode ser encontrado em [PRGM]. No exemplo, o menu apresenta duas opção para o utilizador escolher: sim ou não. Se for escolhida a primeira opção, o programa irá para o comando Lbl A1, onde é mostrado o valor de A e o programa continua normalmente para o fim. Se for escolhida a segunda opção, o programa salta para o comando Lbl B2, onde é terminado o programa.

7 – Outros comandos

7.1 – prgm / Return

O comando prgm permite executar outro programa, exterior ao que está a ser executado. Esse programa deverá estar desarquivado para poder ser executado. O comando é escrito do seguinte modo: prgmNome, onde o NOME é o nome do programa a executar.

O comando Return pode ser colocado num programa que foi chamado através de outro programa. Este comando permite que se retorne ao programa anterior, no comando seguinte ao comando onde o programa foi chamado. Se o programa não tiver sido executado através de outro programa, o comando Return terá o mesmo resultado do que o comando Stop. Não é obrigatório o uso de Return num programa chamado por outro. A seguir estão dois programas que exemplificam o uso destes comandos:

O comando prgm pode ser encontrado directamente em [PRGM]>[EXEC] se o programa já estiver sido criado, ou em [2nd]>[CATALOG]. O comando Return pode ser encontrado em [PRGM]. Se o programa A for executado em primeiro, o programa B será chamado, irá mostrar a mensagem, e voltará ao programa A, onde é terminado. Se o programa B for executado em primeiro, este irá mostrar a mensagem e terminar, sem voltar ao programa A.

Este comando permite eliminar uma variável da memória, libertando o espaço que esta ocupa. A variável a eliminar tanto pode ser uma letra (A,B,C,…), ou uma cadeia, lista, matriz, etc… Se não for atribuído nenhum valor a essa variável depois de esta ter sido eliminada, ela não pode ser utilizada, sob pena de ocorrer um erro. Um exemplo de um programa com este comando:

O comando Delvar pode ser encontrado em [PRGM]. O espaço de memória utilizado pela variável C foi libertado no final do programa. É necessário libertar o espaço de memória de variáveis quando o programa é muito longo e/ou quando usa muitos recursos.

Este comando permite obter uma variável a partir de outra calculadora da gama TI-83. Não é possível obter variáveis de outras calculadoras, já que estas utilizam outros comandos para a mesma função. Este comando pode obter qualquer tipo de variável. O comando é escrito da seguinte forma: GetCalc(variável), onde a variável pode ser A, L1, [A], Str1, etc… Cada vez que for usado o comando deve ser verificado se as calculadoras estão ligadas pelo cabo.

Esta linguagem contém diversos comandos relacionados com desenho. O ecrã de desenho é o mesmo que o ecrã gráfico, que pode ser visto em [GRAPH]. Por isso, muitas vezes é necessário retirar os eixos que aparecem no ecrã gráfico. Isto pode ser feito com o comando AxesOff. Também é preciso ter em atenção que alguns comandos estão relacionados com as coordenadas do ecrã gráfico (x e y) e, por isso, são influenciados pelos valores existentes na secção [WINDOW]. Normalmente usa-se o comando ZStandart para colocar todos os valores predefinidos. A seguir iremos ter um programa que realiza uma pequena animação:

No programa, o comando ClrDraw permite limpar todo o ecrã gráfico. Depois, é iniciado um ciclo de repetição, onde a variável Y é diminuída 0,3 em cada repetição. Dentro de cada ciclo For, temos um comando que desenha uma linha horizontal no ecrã. À frente do comando, deve ser indicado o valor da altura a que vai ser desenhada a linha. Durante o ciclo, Y irá variar de 10 a -10, os valore máximo e mínimo do ecrã gráfico, respectivamente. A seguir ao comando Pause, o ecrã será limpo novamente e os eixos OX e OY serão recolocados. Existe também o comando Vertical que permite desenhar linhas verticais, segundo o valor da abcissa.

Neste próximo programa serão desenhados pontos e linhas, utilizando as coordenadas definidas:

Na primeira parte do programa são desenhados vários pontos, a partir do comando Pt-On, onde são definidas as coordenadas x e y: Pt-On(x,y). Seguidamente, são desenhadas várias linhas, a partir do comando Line, onde são definidas as coordenadas x e y do início da linha e as coordenadas x e y do fim da linha: Line(xinício,yinício,xfinal,yfinal). Depois é apagado o ponto (0,0) com o comando Pt-Off, que funciona como o comando Pt-On. Por fim é utilizado o comando Pt-Change para alterar dois pontos. O ponto (0,0), como não estava desenhado, passou a estar. O ponto (0.3,0), que já estava desenhado, foi apagado. De referir que todas as coordenadas definidas são gráficas.

O comando Pt-On também pode desenhar outros tipos de pontos. Para isso é preciso definir o tipo de ponto desejado: Pt-On(x,y,ponto). O ponto pode ser “1”, que corresponde ao ponto normal (se não for definido o tipo de ponto é este o utilizado), “2”, que corresponde a um quadrado (▫), e “3”, que corresponde a uma cruz (+).Por exemplo, Pt-On(0,0,2), desenha um quadrado nas coordenadas (0,0). Esses pontos também podem ser apagados com o comando Pt-Off, da mesma forma. O comando Pt-Change não suporta esta função.

O comando Circle pode ser encontrado em [2nd]>[DRAW]. Este programa apenas desenha uma circunferência no ecrã, através do comando Circle. Neste comando, os dois primeiros valores são para definir as coordenadas do centro da circunferência, (0,0). O terceiro valor define o raio da circunferência, que neste caso é 5. No entanto, a circunferência não sai perfeito devido ao facto de os valores predefinidos não estarem de forma a se adaptarem ao ecrã rectangular. Para regular estes valores para o desenho de uma circunferência perfeita, é necessário substituir o comando ZStandart pelo ZSquare ([ZOOM]).

Este programa desenha também vários pontos no ecrã, mas, neste caso, não serão definidos por coordenadas gráficas, mas sim pela linha e coluna desejada. O comando Pxl-On desenha um ponto no ecrã da seguinte forma: Pxl-On(linha,coluna). O comando Pxl-Off funciona do mesmo modo, mas apaga o ponto, em vez de o desenhar. Por fim, o comando Pxl-Change actua da mesma forma que o comando Pt-Change, mas usando linhas e colunas. Para facilitar o desenho, o ecrã possui 63 linhas, de 0 a 62, e 95 colunas, de 0 a 94.

Na primeira parte do programa é desenhado um ponto. A seguir, o comando pxl-Test irá verificar se o ponto (10,40) está desenhado. Se estiver este devolve 1 (Verdadeiro), se não estiver este devolve 0 (Falso). Através do ciclo condicional If, se estiver desenhado o ponto, irá ser escrito um determinado texto, neste caso “(10,40) está desenhado”. O comando Text funciona da seguinte forma: Text(linha,coluna,”texto”). Depois, é verificado se o ponto (10,41) está desenhado. Como não está desenhado, a mensagem que aparece é “(10,41) não está desenhado”.

Também é possível guardar imagens, ou seja, tudo o que estiver desenhado no ecrã gráfico. Para isso utiliza-se o comando StorePic, indicando à frente o número da imagem a guardar. O número da imagem pode ir de 0 a 9. Também existe um comando para chamar uma imagem e desenhá-la no ecrã, o RecallPic, onde também é necessário definir o número da imagem. Se já existir alguma coisa desenhada no ecrã, a imagem irá sobrepô-la, mantendo todos os pontos desenhados anteriormente. Se não nenhuma imagem no número definido, quando for chamada uma imagem, irá ocorrer um erro. Para eliminar uma imagem é necessário ir a [2nd]>[MEM]>[Mem Mgmt/Del…]>[Pic…] e seleccionar a imagem a eliminar. Cada imagem ocupa 767 B de RAM. Um pequeno exemplo:

Os comandos StorePic e RecallPic podem ser encontrados em [2nd]>[DRAW]>[STO]. O programa, primeiro desenha duas linhas no ecrã. Depois, guarda essa imagem, com StorePic 1. A seguir é limpo o ecrã. Por fim, é desenhada novamente a imagem com o comando RecallPic 1. É importante guardar uma imagem para uma apresentação inicial de qualquer jogo, ou para guardar uma imagem que, pela sua complexidade, era complicado e longo ter que desenhá-la toda por pontos e linhas.

O objectivo do próximo programa é criar um jogo simples, em que a calculadora escolhe um número aleatoriamente, entre 1 e 99, e o jogador tem que descobrir qual é esse número. A calculadora vai indicando se a tentativa foi mais alta ou mais baixo que o número a descobrir.

No início do programa é atribuído o valor de zero à variável T, que irá contabilizar as tentativas usadas. Depois é usado o comando randInt para criar um valor inteiro aleatoriamente escolhido pela calculadora. O comando é usado da seguinte forma: randInt(valorinicial,valorfinal), em que o valor inicial e final delimitam o intervalo de números que poderão ser escolhidos. O valor resultante deve depois ser guardado numa variável, neste caso N. A seguir é perguntado um número ao jogador. Se a tentativa for mais alta ou mais baixa, aprece a respectiva mensagem, é adicionado 1 a T, ou seja, mais uma tentativa, e o programa volta à pergunta. Se o valor não for mais alto ou mais baixo, então foi acertado no número escolhido. Aparece então a mensagem com o número de tentativas utilizadas.

No próximo programa será demonstrado como fazer um menu gráfico, ou seja, usando o ecrã gráfico e os comandos de desenho para criar um menu diferente. Serão utilizadas as setas na mesma para seleccionar e o [ENTER] para escolher.

No início do programa é atribuído o valor 1 a O, que irá guardar a opção que está a ser escolhida. Depois, são escritas todas as opções no ecrã, incluindo o sinal que irá demonstra a opção seleccionada. A seguir, o programa é parado até o utilizador carregar numa tecla. Se a tecla for para cima é retirado 1 a O e se for para baixo é adicionado 1 a O. Se não for carregado [ENTER], o programa volta ao início, se for é escrita a mensagem respectiva à opção escolhida. Em vez de aparecer uma mensagem, poderia ser adicionado um comando Goto ou outro tipo de seguimento ao programa.

O seguinte programa irá apresentar uma animação, em que as letras de uma palavra caiem até á sua posição.

O programa contém 4 ciclos For, cada um relativo a um caracter da palavra “Olá!”. Em cada ciclo a variável L, relativa á linha em que se encontra a letra, vai de 1 a 5, que corresponde á linha em que as letras ficam. Dentro de cada de cada ciclo é escrita a letra correspondente. Depois, é criado um ciclo For vazio, para funcionar como um curto período de tempo de espera. Por fim, é apagada a letra, para poder ser escrita mais abaixo, no ciclo seguinte.

Uma das preocupações que um programador deve ter é como tornar os seus programas mais pequenos e consequentemente, mais rápidos. Como a calculadora é consideravelmente lenta a correr os programas em linguagem BASIC, a rapidez do programa deve ser uma preocupação constante, especialmente quando se deseja criar jogos. Existem diversas técnicas que podem ser aplicadas para diminuir o código de um programa.

Em muitos casos é possível não terminar a linha de código, ou seja, não colocar a última aspa ou parêntese da linha. No entanto, é necessário ter atenção quando é que isso não causa um erro ou não afecta a sequência do programa. A seguir estão alguns exemplos de como se pode usar esta técnica:

:Menu(“Queres”,”Sim”,S,”Não”,N) :Menu(“Queres,”Sim,S,”Não,N

Os últimos exemplos iriam causar erro no programa. Embora estas alterações de código não sejam muito significativas, apenas um byte por cada carácter a menos, em programas de grande dimensão, é possível notar diferenças de tamanho e velocidade.

Nas condições também é possível evitar mais alguns bytes. Primeira situação:

Esta alteração é possível porque, se N fosse igual a 0, a condição era automaticamente falsa. Portanto, basta que N seja diferente de zero, que a condição fica verdadeira. Agora a situação contrária:

A explicação é a mesma, ou seja, para a condição ser verdadeira, N tem que ser obrigatoriamente 0.

A velocidade de um programa também pode ser afectada por outros factores. Se um programa estiver executado durante um certo período de tempo, a velocidade deste também começa a diminuir. Se existir pouco espaço livre na calculadora, o programa poderá até dar erro de memória. Uma das formas de evitar isto é dividir o programa em vários programas diferentes. Embora isto não facilite as transferências de programas, se o número de programas for elevado, irá aumentar a velocidade dos mesmos.

Espero que tenham aproveitado este tutorial. Se quiserem procurar mais informações e programas como exemplo, existem vários sites que vos podem ajudar. O mais conhecido e utilizado de todos é www.ticalc.org. Este site não só contém muita informação sobre como programar e utilizar todas as calculadora da Texas Instruments, como também possui a maior base de dados de programas e de autores existente. Também é possível criar o nosso próprio espaço, para onde se pode enviar todos os programas feitos, de modo a poderem ser vistos, utilizados e comentados por toda a comunidade.

Para alguma dúvida sobre o tutorial, sugestões, correcções e traduções por favor contactar pelo e-mail: prannock@iol.pt