Introdução a Plua

Porte da linguagem Lua para Palm OS

Como nós sabemos, atualmente existem muitas linguagens de programação disponíveis para as mais diversas finalidades. Uma delas, talvez pouco conhecida em nosso meio, foi desenvolvida aqui no próprio Brasil, para ser mais exato no laboratório Tecgraf/PUC-Rio. A linguagem foi batizada de Lua. Certo, mas o que esta linguagem tem a ver com desenvolvimento para dispositivos móveis? É simples, outro brasileiro resolveu fazer o porte desta linguagem para PDAs com sistema operacional Palm OS, vulgo palms. E esta é conhecida por Plua.

Neste artigo procuraremos fazer uma pequena introdução à linguagem Plua, iniciando com a configuração do ambiente para utilização desta linguagem. Em seguida, conheceremos um pouco da sua sintaxe e, ao final, passaremos para o uso de Plua, mostrando como desenvolver uma aplicação simples, mostrando seu desenvolvimento e simulação.

Introdução à linguagem Lua

De acordo com o site oficial da linguagem, Lua é uma linguagem de programação poderosa e leve (poderosa no fato de nos permitir criar aplicativos bem complexos e práticos, e leve no sentido que quando ela é compilada, seus arquivos ocupam pouca memória nos dispositivos), combinando programação procedural com poderosas construções para descrições de dados, baseadas em tabelas associativas e semântica extensível. É tipada dinamicamente (como PHP, por exemplo), interpretada a partir de bytecodes (como Java), além de gerenciamento automático de memória com coleta de lixo (como em Java).

Esta linguagem, como já citado, foi desenvolvida na PUC-Rio pelo Tecgraf (Grupo de Tecnologia em Computação Gráfica) e atualmente encontra-se na versão 5.1.1, que foi lançada em 09/06/2006. Ela é utilizada em vários projetos, que podem ser vistos aqui.

Atualmente ela pode rodar em máquinas com Windows, Linux, Mac/OS X.

Introdução à Plua

Plua é um porte da linguagem Lua para dispositivos portáteis com sistema operacional Palm OS. Foi desenvolvida por Márcio Migueletto de Andrade, e atualmente sua versão estável é a de número 1.1, que é baseada na versão 4.0.1 da linguagem Lua (já existe uma versão beta (2.0b6), que é baseada na versão 5 da linguagem Lua)

A versão 1.1 de Plua pode ser usada em dispositivos com sistema operacional Palm OS 4 e 5.

Instalando Plua no simulador de Palm OS

Antes de falarmos como desenvolver aplicações em Plua, vamos mostrar como instalar o runtime de Plua no simulador de Palm OS 5.4. Para saber como baixar o simulador Palm OS e instalar aplicações nele, veja o artigo Desenvolvendo aplicações J2ME para PDAs, publicado na edição 5 da WebMobile.

Em primeiro lugar precisamos baixar o Plua para o nosso computador. Para isso, devemos acessar o link http://meusite.uai.com.br/~mmand/plua/plua-1.1.zip para baixarmos a versão 1.1 da linguagem Plua. Feito isso, vamos descompactá-lo num diretório de nossa escolha (em nosso caso, escolhemos descompactar em C:\mobile\plua11). A estrutura de diretórios está apresentada na Figura 1.

Estrutura de diretórios
Figura 1. Estrutura de diretórios.

Onde:

  • doc: contém a documentação (em inglês) da linguagem Plua;
  • examples: contém exemplos de algumas aplicações escritas em Plua (os arquivos possuem a extensão .lua);
  • pluac: contém os compiladores de Plua para Windows e para Linux;
  • prc: contém o runtime da linguagem, um help e o interpretador de comandos da linguagem;
  • libkit.zip: arquivos que contêm as bibliotecas da linguagem.

Vamos então instalar o runtime e o interpretador em nosso simulador. Para isso, vamos ao diretório prc e instalamos os arquivos plua.prc e pluart.prc no simulador. Após a instalação, veja que aparecem os seguintes aplicativos no simulador: Plua e PluaRT (Figura 2).

Plua instalado no simulador
Figura 2. Plua instalado no simulador.

Nessa figura, o aplicativo Plua é o interpretador de comandos e o PluaRT é o runtime da linguagem. Para testarmos se a instalação foi bem sucedida clicamos em PluaRT. Deve aparecer uma tela igual à da Figura 3.

Biblioteca MathLib não encontrad
Figura 3. Biblioteca MathLib não encontrada.

Não se preocupe com este aviso de erro, isto é um aviso de que a biblioteca MathLib não está instalada no simulador, clique em OK e aparecerá a tela da Figura 4.

Runtime de Plua funcionando
Figura 4. Runtime de Plua funcionando.

Para resolvermos este aviso da falta da biblioteca MathLib. Descompacte o arquivo mathlib.zip num diretório de sua escolha e instale o arquivo MathLib.prc no simulador. Feito isto, a tela da Figura 3 não será mais mostrada.

O aplicativo PluaRT é o runtime da linguagem, ou seja, para que as aplicações desenvolvidas e compiladas em Plua funcionem, é necessário que este aplicativo esteja instalado no Palm; mas e o aplicativo Plua, é o que? Ele é um interpretador de comandos, ou seja, um aplicativo no qual podemos escrever na linguagem Plua e executá-los ali mesmo, sem a necessidade de compilação. Só para testar, vamos executar o aplicativo Plua e a Figura 5 irá aparecer.

Interpretador de comandos
Figura 5. Interpretador de comandos.

Agora vamos escrever o código da Listagem 1 nas linhas de texto que aparecem na parte de baixo da tela. Explicaremos o código na continuidade.

Listagem 1. Primeiro exemplo.

pclear()

print(“Olá Mundo! :)”)

print(date())

print(“Versão Palm OS”, _OS_VERSION)

print(“Versão Plua”, _PLUA_VERSION)

print(“Versão Lua”, _VERSION)

Depois de escrito o código, pressionamos o botão Run. Teremos como resultado a saída da Figura 6.

Saída do primeiro exempl
Figura 6. Saída do primeiro exemplo.

Agora vamos às explicações do código. Na linha 1 temos a função pclear(), que serve para limpar a tela. Nas linhas 2 a 6 utilizamos a função print() que recebe como parâmetros strings. Na linha 2 passamos como parâmetro a string "Olá Mundo! :)". Já na linha 3 passamos como parâmetro a função date(), que nos retorna uma string contendo as informações de data e hora do sistema. Nas linhas 4, 5 e 6, temos como parâmetros uma string definida por nós, mais uma string que é uma constante da linguagem Plua. As constantes utilizadas são: _OS_VERSION (linha 4) que contém a versão do sistema Palm OS do dispositivo, _PLUA_VERSION (linha 5) que contém a versão da linguagem Plua instalada no dispositivo e _VERSION (linha 6) que contém a versão da linguagem Lua na qual esta versão de Plua está baseada.

Se observarmos, na mesma Figura 6, além do botão Run, temos também os botões Clear e File. O botão Clear serve para limpar as linhas de texto onde digitamos o código. Já o botão File abrirá uma outra tela como a da Figura 7.

Tela de gerenciamento de arquivos
Figura 7. Tela de gerenciamento de arquivos.

Além do Plua ser um interpretador de comandos, podemos escrever nossas aplicações em Plua no programa Memos do Palm e abri-los dentro do File do aplicativo Plua. Dessa forma, podemos criar, salvar, editar, compilar e executar nossas aplicações em Plua diretamente no Palm, sem a necessidade de um computador. Para demonstrar esta utilidade da ferramenta, acessamos o Memos do Palm e criamos um memo com o código da Listagem 2 (Nota 1).

Listagem 2. Exemplo de arquivo no programa Memo.

-- teste.lua

pclear()

print(“Olá Mundo! :)”)

print(date())

print(“Versão Palm OS”, _OS_VERSION)

print(“Versão Plua”, _PLUA_VERSION)

print(“Versão Lua”, _VERSION)

pevent()
Nota 1. Executando o Memos no Palm

Se o leitor nunca usou um Palm real ou o simulador do Palm, para executar o Memos siga os seguintes passos:

  1. No simulador, clique no ícone da casinha, que se encontra na parte inferior à esquerda;
  2. Caso a tela da Figura 8 não seja mostrada, clique no ícone da casinha novamente até que a tela mostrada seja igual à da Figura 8; esta é a tela inicial do gerenciador de aplicações do Palm OS;

    Gerenciador de aplicações do Palm
    Figura 8. Gerenciador de aplicações do Palm.
  3. Agora procure pelo aplicativo Memos ou Memo Pad (no caso do nosso simulador), cujo ícone é similar a um bloco de textos com um lápis sobre ele.
  4. Clique sobre ele e a tela da Figura 9 será mostrada;

    Programa Memos
    Figura 9. Programa Memos.
  5. Para criar um novo Memo, clique em New ou Novo. Agora basta digitar o código no memo (Figura 10) e clicar no botão Done ou OK.

    Criando um novo memo (Arquivo teste.lua)
    Figura 10. Criando um novo memo (Arquivo teste.lua).

Aqui vale uma observação: para que o programa escrito no memo seja visto na tela File do programa Plua como um arquivo código-fonte Plua, a primeira linha deve sempre conter dois hífens --, seguido de um espaço em branco e depois o nome do arquivo com a extensão .lua, por exemplo, -- teste.lua (Linha 1). Assim, o arquivo será visto na tela File do programa Plua, como mostrado na Figura 11.

Comentando o código, não temos muito a acrescentar, a não ser pela função adicionada na Linha 8. A função pevent() bloqueia a execução do código até que um evento aconteça. Entre os eventos que podem ocorrer temos, o pressionamento de um botão do Palm ou um toque na sua tela.

Tela de gerenciamento de arquivos
Figura 11. Tela de gerenciamento de arquivos.

Tendo criado o arquivo no Memos e aberto o File no programa Plua, podemos executar qualquer uma das opções dos botões que se encontram nesta tela: Run, Compile, New, Edit, Main.

O botão Run, como o próprio nome diz, serve para executarmos nossa aplicação; o botão Compile irá compilar nossa aplicação e gerar um arquivo .prc que será instalado na memória do Palm; o botão New criará um novo arquivo no Memos para que possamos editá-lo com o botão Edit (nosso exemplo que editamos antes no Memos poderia ter sido feita através desta opção) e explicaremos mais à frente; o botão Edit, serve para editar os códigos-fonte escritos no Memos e o botão Main volta para a tela principal do programa Plua.

Para continuarmos, clicamos no botão Run e vemos o nosso exemplo funcionando (Figura 12). Para sair desta tela basta clicar sobre ela que voltaremos para o File do Plua.

Aplicativo executando
Figura 12. Aplicativo executando.

Se ao invés de clicarmos em Run, clicarmos em Compile, uma tela será mostrada, onde escolhemos se nossa aplicação será um aplicativo ou uma biblioteca, qual o Creator ID da aplicação, o nome da aplicação, qual a versão e se terá título ou não. Preencha tudo conforme mostrado na Figura 13 e pressione Ok.

Quando o botão Ok for pressionado, voltamos para a tela File do Plua. Para ver nosso aplicativo compilado, basta clicar no ícone da casinha que a tela da Figura 14 se abrirá e nela podemos ver o ícone da nossa aplicação, TesteLua (caso a tela da Figura 14 não se abra, basta clicar novamente no ícone da casinha até que ela apareça). Agora basta clicar sobre o ícone do TesteLua que o nosso aplicativo será executado e a tela da Figura 12 será mostrada.

Compilando a aplicaçã
Figura 13. Compilando a aplicação.
Aplicativo compilado
Figura 14. Aplicativo compilado.

Tendo terminado esta parte, passemos agora para uma explicação básica da sintaxe da linguagem Plua.

Sintaxe básica da linguagem Lua

Como Plua é um porte da linguagem Lua, ela usa a mesma sintaxe desta linguagem, que é similar à sintaxe da linguagem Pascal. Assim, explicaremos usando exemplos para Plua mesmo. Não esqueça que todos os exemplos que utilizarmos neste tópico poderão ser escritos e executados no próprio simulador para que possamos ver a saída do resultado de cada um.

Cada linha de código de um programa em Plua pode conter um ou mais comandos, onde cada comando é uma chamada a uma função, atribuição de variáveis, dentre outros. Por exemplo:

print("TESTE INICIAL") é um comando. Um comando pode ou não ser terminado com um delimitador (no caso de Plua é usado o ;, como em Pascal ou Java).

Como dito anteriormente, Plua é uma linguagem tipada dinamicamente, ou seja, não definimos tipos para as variáveis que declaramos. Os tipos da variáveis são declarados em tempo de execução. Por exemplo:


a = 6

b = 3

c = a + b

print(c)

Veja aqui que as variáveis a e b são inteiros, mas não declaramos seu tipo. E, por este exemplo acima, podemos ver também que a atribuição a uma variável é feita usando-se o sinal =.

Como toda linguagem, Plua também tem suas estruturas de controle que são: if, while e repeat e suas sintaxes estão descritas nas Listagens 3, 4 e 5:

Listagem 3. Sintaxe do comando WHILE.

a = 0

while a < 4 do

    print(a)

    a = a + 1

end
Listagem 4. Sintaxe do comando REPEAT.

a = 0

repeat

    print(a)

    a = a + 1

until a == 4
Listagem 5. Sintaxe do comando IF.

a = 8

if a > 10 then

    print(“a > 10”)

else

    print(“a < 10”, a)

end

Para encerramos essa discussão sobre a sintaxe básica da linguagem, apresentamos a estrutura de repetição for, que possui duas formas de uso, descritas nas Listagens 6 e 7.

Listagem 6. FOR (1) – chamado de numeric for, mais usado para percorrer sequências numéricas.

for a = 1, 5, 1 do

    print(a)

end
Listagem 7. FOR (2) – chamado generic for, mais usado para percorrer tabelas.

letras = {“a”, “b”, “c”, “d”}

for i, v in letras do

    print(i, v)

end

Agora vamos desenvolver uma aplicação na qual possamos explorar um pouco da biblioteca gráfica de Plua. Mas antes vamos explicar como compilar nossas aplicações num computador com Windows.

Compilando um exemplo no prompt do DOS

té agora sabemos que podemos escrever nossas aplicações tanto no programa de memos quanto no próprio interpretador de comandos. Ainda temos a opção de editarmos nossos arquivos .lua em um computador (rodando windows ou linux) e compilá-los para depois enviá-los para o simulador.

Para isso, vamos editar o arquivo da Listagem 2 em um editor de textos (você pode usar qualquer editor de textos). Quando editar o arquivo, salve-o com o nome primeiro.lua no diretório de sua escolha (em nosso caso salvamos em C:\plua).

A seguir, abra o prompt de comandos do DOS e digite os comandos descritos na Listagem 8 (supondo que você tenha descompactado o arquivo plua-1.1.zip em C:\mobile\plua11).

Listagem 8. Compilando um programa em Plua no computador.

c:

cd 
cd mobile\plua11\pluac\windows

pluac Primeiro prm1 1.0 C:\plua\primeiro.prc c:\plua\primeiro.lua

Veja que este comando, pluac, recebe cinco argumentos, sendo:

  • o primeiro (Primeiro): é o nome da nossa aplicação;
  • o segundo (prm1): o creator ID, de quatro caracteres, obrigatório para os programas para Palm OS;
  • o terceiro (1.0): o número da versão que damos à nossa aplicação;
  • o quarto c:\plua\primeiro.prc): o local e o nome do arquivo compilado, neste caso, o arquivo será gerado dentro do diretório c:\plua com o nome de primeiro.prc;
  • o quinto C:\plua\primeiro.lua: o local e o nome do arquivo fonte, neste caso, o arquivo está dentro do diretório c:\plua com o nome de primeiro.lua.

Criando o primeiro exemplo

Agora vamos criar uma aplicação gráfica simples para que possamos demonstrar na prática o uso da linguagem Plua. Nossa aplicação será composta apenas de uma tela principal, que será utilizada para um cadastro de livros. Ao final de cada cadastro mostramos os dados do livro cadastrado. Na Listagem 9, temos todo o código da aplicação, com alguns trechos explicados.

Listagem 9. livros.lua

-- livros.lua

-- programa para cadastro de livros



-- função para centralização de texto na tela

function centralizar(texto)

    local _texto = texto

    local tam = ptextwidth(_texto)

    local w = pmode()

    local meio = (w - tam)/2

    return meio

end



-- função para limpeza dos campos do formulário

function limparCampos()

    psettext(fTitulo, "")

    psettext(fAutor, "")

    psettext(fCateg, "")

    psettext(fComent, "")

    psetfocus(fTitulo)

end



-- limpa a tela

pclear()

-- cria uma barra de título para o programa

ptitle("Livros")

txtPrograma = "Cadastro de Livros"

-- centraliza texto e move para posição centralizada

pmoveto(centralizar(txtPrograma), 32)

plabel(txtPrograma)

-- posiciona e cria um label e um campo de texto

-- Título

pmoveto(5, 70)

plabel("Título")

fTitulo = pfield(1, 20, 30)

-- posiciona e cria um label e um campo de texto

-- Autor

pmoveto(5, 100)

plabel("Autor")

fAutor = pfield(1, 20, 30)

-- tabela contendo os itens da lista

tabCateg = {"", "Suspense", "Ficção", "Policial"}

-- posiciona e cria um label e lista de itens

-- Categoria

pmoveto(5, 130)

plabel("Categoria")

fCateg = ppopup(tabCateg)

-- posiciona e cria um label e um campo de texto com três linhas

-- Comentários

pmoveto(5, 160)

plabel("Comentários")

fComent = pfield(3, 20, 200)

-- adiciona botões à aplicação

pmoveto(5, 290)

botInserir = pbutton("Inserir")

botSair = pbutton("Sair")



while 1 do

    e, id = pevent()

    if e == ctlSelect then

        if id == botSair then

            exit()

        elseif id == botInserir then

            txtTitulo = pgettext(fTitulo)

            txtAutor = pgettext(fAutor)

            txtCateg = pgettext(fCateg)

            txtComent = pgettext(fComent)

            palert("Título: "..txtTitulo.."\nAutor: "..txtAutor.."\nCategoria: "..txtCateg.."\nComentários: "..strsub(txtComent, 1, 30))

            limparCampos()

        end

    end

end

Como dissemos, esta aplicação é somente composta de uma tela de cadastro de livros, onde inserimos alguns dados de um livro qualquer. Nesse cenário, quando inserimos um livro (que poderia ser salvo num arquivo texto, por exemplo, mas que em nossa aplicação de exemplo não será feito) uma tela de alerta é mostrada com os dados que estão sendo inseridos e ao se clicar na confirmação da tela, os campos do formulário são limpos para que possamos cadastrar um novo livro.

Todas as linhas iniciadas por dois hífens (--) são comentários, ou seja, são trechos que não são interpretados pelo compilador. Vamos começar pela função centralizar() (linhas 5 a 11). Esta função objetiva escrever um texto qualquer centralizado na tela do Palm. Na linha 5 temos a declaração da função que começa com a palavra function seguida do nome da função e seus parâmetros entre parênteses. Na linha 6, pegamos a variável texto que é passada como parâmetro na função centralizar() e a armazenamos numa variável local local _texto = texto. Variáveis locais são aquelas que têm seu escopo delimitado dentro de um bloco, por exemplo, uma função ou uma estrutura de repetição. Para se declarar uma variável local em Plua, basta apenas que se coloque a palavra local antes do nome da variável. Na linha 7 temos o método ptextwidth(), que recebe como parâmetro uma string e nos retorna um valor que representa a largura da string a ser escrita na tela. Na linha 8, a função pmode() nos retorna as dimensões da tela, assim, armazenamos na variável w a largura total da tela do Palm. Se após a variável w colocássemos uma variável h, por exemplo, ela armazenaria a altura da tela do dispositivo, exemplo: local w, h = pmode(). Nas linhas 9 fazemos um simples cálculo para obter o valor que corresponde ao meio onde o texto será escrito e retornamos ele na linha 10. A linha 11 fecha a função com a palavra end. Se observarmos, vemos que a palavra end serve tanto para fechar a função como para fechar estruturas de controle.

Nas linhas 14 a 20 temos a função limparCampos(), que serve unicamente para limpar os campos que estão na tela para que se possa cadastrar novo livro. Nas linhas 15 a 18 usamos a função psettext(), que utiliza dois parâmetros; no primeiro é passada a identificação do componente gráfico que se quer trabalhar (em nosso caso, são campos de texto e uma caixa de seleção) e no segundo temos o texto a ser colocado neste componente. Na linha 19, o método psetfocus() serve para colocar o foco do cursor no componente desejado.

Como parte do código fonte está comentado, vamos nos ater a explicar algumas funções. A função pmoveto() recebe como parâmetros dois valores que servem para posicionar um cursor imaginário na tela onde será colocado o componente que vier logo abaixo dela. Por exemplo, na linha 28 temos o pmoveto(centralizar(txtPrograma), 32), lembrando que a função centralizar() retorna um número inteiro. Em seguida, temos a função plabel(txtPrograma) (linha 29) que posicionará nosso label nas coordenadas passadas como parâmetro para a função pmoveto() da linha 28. Note que esta mesma estrutura se repete ao longo do programa, ou seja, usamos pmoveto() para indicar a posição em que um componente será posicionado e depois o declaramos.

Na linha 34 criamos um componente pfield() que recebe como parâmetros três valores, sendo: (1) a quantidade de linhas que o componente terá; (2) o número de colunas que o componente terá; e (3) o número máximo de caracteres suportados pelo componente. Observe que uma variável recebe o retorno do componente pfield(). Isso ocorre porque cada componente gerado em Plua tem como retorno um identificador (ID) que pode ser armazenado em uma variável para que possamos fazer referência a este componente em outra parte do código (observe a função limparCampos() no início do programa, por exemplo).

Na linha 41 criamos uma tabela que será utilizada num componente de caixa de seleção (linha 46). Ela é criada com os caracteres “{“ e “}”, e seus itens são separados por vírgula.

Nas linhas 54 e 55 criamos dois botões que servirão para cadastrar o livro e para sair do programa.

Da linha 57 à linha 71 temos o nosso controle de fluxo que fica permanentemente executando numa estrutura de controle while (linha 57). Caso ocorra algum evento, este é capturado nas variáveis e (para o evento em si) e id (para o componente que gerou o evento), na linha 58. Logo abaixo, na linha 59, o evento e é testado e comparado com ctlSelect (o pressionamento de um dos botões, por exemplo), e, se a comparação for verdadeira, ela será testada se foi feita pelo botão de saída, botSair (linha 60) ou se foi feito pelo botão de inserção, botInserir (linha 62).

Se o botão selecionado tiver sido o botão botSair, então a função da linha 61, exit(), será executada. Esta função somente faz sair da aplicação. Se tivermos pressionado o botão botInserir, as ações das linhas 63 a 68 serão executadas. Das linhas 63 a 66 capturamos o texto escrito ou a opção selecionada nos componentes descritos em cada parâmetro e os armazenamos em variáveis para os utilizarmos na linha 67. Na linha 67 temos a função palert() que criará uma tela de alerta no Palm e exibirá uma string contendo as variáveis da linha anterior. Veja que para concatenar (juntar) duas ou mais strings usamos dois pontos em seqüência (..).

Agora que explicamos nossa aplicação, vamos compilá-la e executá-la no simulador.

Compilando e executando o primeiro exemplo

Para compilar, basta abrir um prompt do DOS em seu computador e digitar os comandos descritos na Listagem 10.

Listagem 10. Compilando o exemplo do cadastro de livros.

c:

cd 
cd mobile\plua11\pluac\windows

pluac Livros livr 1.0 C:\plua\livros.prc c:\plua\livros.lua

Agora para testar, copiamos o arquivo livros.prc gerado para o simulador e quando tiver sido instalado executamos o programa Livros (Figura 15).

Aplicação Livros
Figura 15. Aplicação Livros.

A tela inicial da nossa aplicação é a mostrada na Figura 16A, e na Figura 16B já temos os dados de um livro que queremos cadastrar.

(A) Aplicação Livros em execução (B) Cadastrando um livro.
Figura 16. (A) Aplicação Livros em execução (B) Cadastrando um livro.

Ao terminar de preencher os dados, podemos clicar no botão Inserir para inserir o nosso livro (note que não temos um local para persistir os dados, assim depois que eles forem cadastrados e inseridos serão simplesmente apagados). Mas é claro que em uma aplicação real, um modo de persistência seria usado, como um arquivo texto, por exemplo) (Figura 17). Na tela que se abre, ao clicarmos no botão Ok, os campos do formulário serão limpos e podemos cadastrar um novo livro. Para sair da aplicação basta clicar no botão Sair.

Livro já cadastrado
Figura 17. Livro já cadastrado.

Recursos disponibilizados por Plua

Antes de finalizarmos, vamos citar alguns outros recursos que a linguagem Plua oferece. Além, é claro, de suporte a interface gráfica dos sistemas Palm OS, temos:

  • uma estrutura de funções para acesso a estrutura de dados (criação de PDBs), tanto entrada quanto saída;
  • suporte a conexões socket por TCP ou UDP;
  • funções para criação e tratamento de diretórios (em cartão de memória, caso este esteja disponível);
  • funções de acesso a porta serial, tanto RS-232 (serial comum, igual aquela dos mouses seriais) quanto infrared (IrComm - infravermelho);
  • funções para controle de som;
  • e suporte a biblioteca padrão da linguagem Lua.

Conclusão

Como o leitor deve ter percebido, Plua é uma linguagem de programação bem simples e que nos permite criar aplicações mais complexas do que a deste artigo. Esperamos que sirva de introdução e estímulo de uso para aquele leitor que ainda não encontrou uma linguagem de programação que o ajude a desenvolver suas aplicações.

Como dissemos anteriormente, a versão de Plua utilizada neste artigo foi a versão 1.1, que tem uma característica maior de se parecer com programação estruturada. A versão 2.0 desta linguagem já está em desenvolvimento e tem características de programação orientada a objetos.