<h3>Usando eLua</h3><p> Bem, você já<ahref="building.html">construiu</a> e <ahref="installing.html">instalou</a><b>eLua</b>, e agora está na hora (finalmente) da curtir eLua :)
Você pode compilar <b>eLua</b> utilizando tanto uma conexão serial (UART, longe de ser a mais comum) como uma conexão TCP/IP (neste caso, ainda em testes, mas funcionando muito bem), logo existem dois cenários para esta situação (veja também <ahref="building.html">building eLua</a> para mais detalhes de como escolher entre console serial ou TCP/IP).</p>
<aname="uart"><h3>Usando eLua com uma conexão serial</h3></a>
<p>Tudo o que você precisa para usar <b>eLua</b> com uma conexão serial é de sua placa <b>eLua</b> conectada a um PC rodando um programa emulador de terminal.<br>Se
você está usando o Windows, recomendo o <atarget="_blank"href="http://www.ayera.com/teraterm/">TeraTerm</a>.
É gratuito, possui muitos recursos e é fácil de usar. O pré-instalado Hyper Terminal também pode ser usado, porém dê uma chance ao TeraTerm, pois ele é muito melhor do que o HyperTerm IMO.<br>Se você usa o
irá provavelmente se deparar com o minicom a qualque momento. Ele não é muito intuitivo e roda em modo texto, mas possui bastante recursos. Se você
pesquisar no google por "minicom tutorial", poderá aprender rapidamente como instalá-lo e utilizá-lo. Você
pode tentar outros emuladores, desde que configure-o
adequadamente e que ele permite que você faça transferência de arquivos
via XMODEM, que no momento é o processo que <b>eLua</b> utiliza. Estes sáo os principais
parâmetros a serem configurados:</p>
<ul><li>configuraçáo da porta: 115200 baud (38400 para o <ahref="installing_str7.html">STR7)</a>, 8N1(8 bits de dados, sem paridade, um stop bit). </li><li>controle de fluxo do hardware: nenhum</li><li>como interpretar uma nova linha: "CR" na recepção, "CR+LF" no envio (alguns emuladores não permitem essa opção). </li></ul>
<p>Além disso, dependendo do tipo da sua placa, você irá precisar conectá-la a uma porta serial do seu PC ou a uma porta USB, caso esteja usando um conversor USB/Serial. Por exemplo, como já foi explicado <ahref="installing_lm3s.html">aqui</a>,
a porta USB nas placas LM3Sxxxx possui duas conexões, portanto você pode usá-la como um conversor de USB para serial depois de atualizar o firmware, sendo assim, você não precisa de nenhum outro tipo de conexão. O mesmo acontece com a placa STR9-comStick. Entretanto, para a placa SAM7-EX256 você precisará conectar um cabo serial ao conector "RS232", desde que
os jumpers já estejam configurados como explicado <ahref="installing_at91sam7x.html">aqui</a> e para a placa MOD711 você precisará acrescentar um chip conversor RS232.
Não existe uma única regra, tudo depende do modêlo da sua placa.
</p>
<aname="tcpip"><h3>Usando eLua com uma conexão TCP/IP</h3></a>
<p>As coisas ficam bem mais fáceis se você decidir usar uma conexão TCP/IP:
<ul>
<li>certifique-se que você conhece o endereço de sua placa. Se você habilitou IP estático (veja <ahref="building.html">construindo</a>). lembre-se qual o IP escolhido; caso esteja usando DHCP, seu servidor DHCP deve ter incluído o endereço de sua placa <b>eLua</b> como seu DNS. O nome da placa sempre é "elua", logo caso você execute um "ping elua" a partir do shell poderá verificar se a placa está ativa.</li>
<li>um telnet para o endereço da placa (ou simplesmente "telnet elua" com DHCP ativo), e você será recebido pelo shell prompt da placa (se o shell estiver ativo, leia o próximo parágrafo para mais detalhes).
É importante salientar, que a placa <b>eLua</b> só poderá estar conectada a uma sessão telnet ativa a cada instante.</li>
</ul>
</p>
<p>Se você está rodando Windows, certifique-se que esteja utilizando um telnet adequado, o que significa na prática "tudo menos o telnet nativo".
<atarget="_blank"href="http://www.chiark.greenend.org.uk/~sgtatham/putty/">PuTTY</a>é muito popular e uma boa opção.</p>
<aname="pc"><h3>Usando eLua "standalone" em seu PC</h3></a>
<p>Se você construiu <b>eLua</b> para a plataforma i386, poderá dar boot direto pela placa <b>eLua</b>! Sem sistema operacional controlando o seu computador, somente <b>eLua</b> puro. Não haverá nenhum periférico para ter acesso, mas podemos usar o módulo term para executar o <i>hangman.lua</i> e o <i>life.lua</i>, bem como outros exemplos, o que o torna uma boa demonstração :) Siga <ahref="installing_i386.html">
este link</a> para obter informações específicas sobre a plataforma i386. </p>
<p>Não importa como você está conectado fisicamente (serial, TCP/IP ou pelo seu monitor de vídeo do PC após o boot com <b>eLua</b>), depois que você configurar a conexão PC-placa <b>elua</b> (se aplicável) e pressionar o botão "RESET" de sua placa ou simplesmente pressionar ENTER se você estiver usando uma conexão serial, você deve ver o shell prompt de <b>eLua</b> (se na construção de eLua, o shell prompt foi habilitado como descrito <ahref="building.html">aqui</a>). O shell é um simples interpretador de comandos interativo que permite:
<ul>
<li>fornece uma ajuda para o uso do interpretador com o comando help</li>
<li>roda o interpretador Lua no modo interativo da mesma forma que fazemos em nosso computador</li>
<li>roda programas Lua a partir do sistema de arquivo eLua</li>
<li>transfere arquivo fonte via XMODEM e execute-o</li>
<li>mostra a versão de eLua</li>
<li>lista arquivos eLua</li>
</ul></p>
<p>Segue abaixo uma descrição detalhada de todos os comandos.</p>
<h2>help</h2>
<p>Mostra uma lista de todos os comandos disponíveis.</p>
<h2>ver</h2>
<p>Mostra a versão da imagem de <b>eLua</b> instalada na placa. Atualmente, a versão é somente incrementada por atualizações oficiais, logo se é liberada uma versão intermediária, esta não interfere no número da versão.</p>
<h2>recv</h2>
<p>Permite que você receba um arquivo eLua (tanto arquivos fontes quanto compilados) via
XMODEM e execute-o em sua placa. Para usar este comando, é necessário que a imagem do seu <b>eLua</b> tenha sido configurada para suportar XMODEM
(veja <ahref="building.html">construindo</a> para mais detalhes). Além disso, o seu programa emulador de terminal deve suportar o envio de arquivos via protocolo XMODEM. Ambos XMODEM com checksum e XMODEM com CRC são suportados, no entanto sóé aceito o XMODEM com pacotes de 128
bytes (XMODEM com pacotes de 1K não funciona).
Para usar esse recurso, digite "recv" no prompt do shell. eLua responderá com
"Waiting for file ...". Neste momento, você poderá enviar o arquivo para a placa eLua
via XMODEM. eLua receberá e executará o arquivo. Não se preocupe quando ver o
caracter 'C' aparecendo em seu terminal depois de entrar como esse comando,
pois essa é a forma como o XMODEM é inicializado.<br>
Como o XMODEM é um protocolo que se utiliza de comunicação serial, este comando não está disponível caso você esteja usando uma conexão TCP/IP.<br>
Caso você esteja querendo enviar arquivos binários já compilados ao invés de código fonte para <b>eLua</b>, veja antes <ahref="using.html#cross">essa sessão</a>.
</p>
<h2>lua</h2>
<p>Esse comando inicia a interpretador Lua, aceitando opcionalmente parâmetros na linha de comando, exatamente
como se você estivesse em seu computador. O comando possui algumas restrições:</p>
<ul><li>No máximo 50 caracteres para o tamanho da linha de comando</li>
<li>a sequência 'ESC` não foi implemantada. Por exemplo, o seguinte comando não funcionará
devido a sequência 'ESC' com ' ('aspas simples') somente:
<p>Caso você queira executar um arquivo a partir do <ahref="">##ROM file system</a>, não se esqueça de colocar antes do nome do arquivo o prefixo <i>/rom</i>. Por exemplo, para executar o arquivo <b>hello.lua</b>, digite o seguinte:</p>
<p>Lista todos os arquivos do sistema de arquivos utilizado por <b>eLua</b> (atualmente armazenado em ROM), bem como o total ocupado e o espaço total do sistema de arquivos.</p>
<h2>exit</h2>
<p>Sai do shell. Esse comando só faz sentido, caso você tenha compilado <b>eLua</b> para conexão sobre TCP/IP, já que a sessão telnet é encerrada com a placa <b>eLua</b>. Caso contrário o comando simplesmente encerra
o shell e trava até você resetar sua placa.</p>
<aname="cross"><h3>Cross-compilation: compilando seus programas eLua para uma plataforma diferente</h3></a>
<p><i>Cross-compilation</i>é o processo de compilação de um programa em uma platforma com obejtivo de ser
utilzado em uma outra plataforma. Por exemplo, o processo de compilação para gerar uma imagem binária de <b>eLua</b> em
seu PC para uso na sua placa <b>eLua</b>é o que chamamos de "cross-compiling". Lua pode ser compilada dessa forma também. Ao compilar Lua usando esse procedimento
você tem algumas vantagens importantes:
<ul>
<li><b>volocidade</b>: o compilador Lua na placa <b>eLua</b> não precisa compilar o código fonte Lua
, simplesmente executa o código binário.</li>
<li><b>memória</b>: caso você esteja executando diretamente um código binário, nenhuma memória a mais
é "gasta" em placa <b>eLua</b> para compilação do código Lua para bytecode.
Muitas vezes isso é a "salvação". Caso você esteja tentando executar código Lua direto de sua placa e recebendo a mensagem de erro "not enough memory",
pode mudar esse resultado compilando o programa Lua em seu PC e depois
executando o arquivo gerado. Alé disso, compilar programas Lua muito grandes em sua placa
<b>eLua</b> pode acarretar estouro de pilha, o que normalmente nos leva a erros difíceis de serem encontrados.</li>
</ul></p>
<p>Para usar "cross-compilation", as duas plataformas Lua (neste caso seu PC e sua placa <b>eLua</b>) devem ser compatíveis
(devem ter os mesmos tipos de dados, com os mesmos tamanhos e a mesma representação de memória).
Isto não é verdadeiro sempre. Por exemplo, alguns toolchains gcc para arquitetura ARM usam como padrão uma representação muito específica para números com dupla precisão (conhecida como formato FPA), tornando dessa forma, os arquivos bytecode gerados no PC com um compilador Lua inúteis para as placas ARM. Outros toolchains não possuem esse problema. Outras arquiteturas (como a AVR32) são "big endian", ao contrário da plataforma Intel para PCs que é "little endian".<br>
Para resolver esses tipos de problemas, um patch para "Lua cross-compilation" foi enviado para a lista de e-mails de Lua
a pouco tempo atrás, e foi bastante modificado como parte do projeto <b>eLua</b>
para funcionar com a arquitetura ARM. Aqui está como usá-lo (as instruções abaixo foram testadas em Linux, não em Windows, mesmo assim, elas devem funcionar também no Windows com pouco ou quase nenhum esforço):
<ul>
<li>primeiro, certifique-se que seu PC já esteja com todos os arquivos necessários para a construção de um <b>eLua</b> (gcc,
binutils, libc, headers...). Você precisará também do scons. A boa notícia é que você já deve ter o scon instalado em seu sistema,
já que, caso contrá você não seria capaz nem mesmo de construir <b>eLua</b> (veja <ahref="building.html">construindo</a> para instruções mais detalhadas).</li>
<li>a partir do diretório base de <b>eLua</b>, digite o seguinte comando:</li>
<p>Esse comando gera um arquivo chamado <i>luac</i> no mesmo. É quase a mesma coisa que no compilador comum, mas possui alguns poucos argumentos para lidar com as diferenças entre as diversas arquiteturas (mostradas abaixo em negrito):</p>
-o name output to file 'name' (default is "luac.out")
-p parse only
-s strip debug information
-v show version information
<b>-cci bits cross-compile with given integer size
-ccn type bits cross-compile with given lua_Number type and size
-cce endian cross-compile with given endianness ('big' or 'little')</b>
-- stop handling options</code></pre></p>
<p>Tudo que deve ser feito agora é usar a tabela abaixo para identificar qual os parâmetros certos para serem utilizados no cross-compiler:</p>
<td><code>./luac -ccn int 32 -cce little -o <script.luac> -s <script.lua></code></td>
</tr>
<tr>
<td>Ponto Flutuante (lua)</td>
<td>AVR32</td>
<td><ahref="toolchains.html">avr32-gcc</a>
<td><code>./luac -ccn float 64 -cce big -o <script.luac> -s <script.lua></code></td>
</tr>
<tr>
<td>Inteiro (lualong)</td>
<td>AVR32</td>
<td><ahref="toolchains.html">avr32-gcc</a>
<td><code>./luac -ccn int 32 -cce big -o <script.luac> -s <script.lua></code></td>
</tr>
</tbody>
</table>
<p>(observe que se por alguma razão você precisa de um cross-compile <b>eLua</b> para x86, poderá usar o próprio compilador Lua).<br>
Você pode omitir o parâmetro <i>-s</i> (de strip) da compilação, mas isso resultará em arquivos binários maiores (quando não se usa o parâmetro <i>-s</i>, a informação de debug não é removida do arquivo gerado).</p>
<p>Você pode usar o arquivo gerado de duas formas:</p>
<ul>
<li>gravá-lo em uma <ahref="arch_romfs.html">ROM do sistema de sua placa</a> e executá-lo a partir daí.</li>
<li>usar o comando <i>recv</i> a partir <ahref="using.html#shell">do shell</a> para enviá-lo para a placa usando uma conexão serial.</li>
