Uma introdução ao Dialog com Raspberry

Para usar bem os recursos do Raspberry, dominar Linux é indispensável. Mas se o caso for entregar uma interface para o usuário interagir, a solução mais rápida é, sem dúvidas, utilizar Dialog com Raspberry. O resultado será essa interface da imagem de destaque.

Shell script

O Linux é poderosíssimo. Já mostrei até como fazer comunicação socket por shell script, nesse outro artigo. O UNIX tem outro tipo de comunicação socket para IPC (inter-process communication), que é o UNIX sockets, sem a necessidade da pilha TCP/IP, descrito nesse outro artigo.

Utilizando shell script podemos fazer praticamente qualquer tarefa no sistema. Antigamente o Linux era praticamente um monte de shell script inicializando os processos de sistema. Hoje temos uma parte desses processos sendo executados de outra forma, mas sem dúvidas o shell estará lá, sempre. Até a Microsoft incluiu o bash no Windows 10.

O que é o Dialog

O Dialog é uma ferramenta utilizada para criar menus para scripts shell. Desse modo, uma interface amigável é disponibilizada para o usuário e evitamos que nossos clientes precisem digitar algum tipo de comando.

O Dialog oferece caixas de diálogos de diversos tipos; desde caixa de mensagem à calendário. Sua utilização é simples, não havendo impacto na implementação. Mas o Dialog não vem instalado por padrão, por essa razão deveremos instalá-lo previamente.

Instalação do Dialog

Para utilizar o código disposto aqui do Dialog com Raspberry, algumas ferramentas extras deverão ser instaladas. Instale tudo agora para evitar trabalho posteriormente:

sudo su
apt-get update
apt-get install dialog dnsutils

O pacote dnsutils será utilizado para pegar o IP público sem que seja necessário recorrer a algum site como whatsmyip.com.

Exemplo básico com Dialog com Raspberry

Primeiramente, faça o teste. Use o comando abaixo para criar um diálogo de sim/não.

dialog --stdout --title "Manual do Maker" --yesno "Sim ou não?" 0 0

Esse comando abrirá uma caixa como essa:

O Dialog devolverá um código de retorno, como qualquer programa. Para pegar o código de retorno basta analisar a variável do shell que guarda o último status:

echo $?

Para yes o retorno é 0. Para no o retorno é 1. Mas não podemos apenas utilizar o dialog sem que haja uma rotina a ser executada em cada status. Bem, até podemos, mas não seria um programa ainda:

dialog --stdout --title "Deseja catchup?" --yesno "Sim ou não?" 0 0 || dialog --stdout --infobox "Ok. Sem catchup." 0 0

O código de saída 0 é saída considerada normal. Utilizando dois pipes ('||'), dizemos que "a saída deve ser normal, ou então toma-se uma ação". Sendo yes = 0, se escolhermos sim para catchup, nada acontece. De outro modo, um diálogo infobox devolverá a mensagem "Ok. Sem catchup.":

Shell script básico

Recomendo fortemente o livro de Julio Cezar Neves para quem quer aprender shell script. Além de ser uma leitura muito divertida, o conteúdo é impecável. O primeiro livro dele eu comprei lá pro começo dos anos 2000.

O que vou colocar aqui é uma introdução parca conceitual, apenas para despertar o entendimento inicial de um script. Não tenho a menor intenção de escrever esse artigo para tornar alguém programador shell, até porque o assunto é tão extenso que somente um livro como o recomendado acima poderia ajudar.

O mínimo que precisamos escrever em um arquivo de texto plano é o header, depois dar permissão de execução para esse arquivo. Comumente chamamos um script shell de algumacoisa.sh. O .sh é apenas um identificador para o usuário, em Linux não precisamos de extensão para identificar tipos de arquivos.

Vamos apenas fazer o "Hello World":

#!/bin/bash
echo "Hello World"

Para transformá-lo em executável, devemos mudar ao menos o primeiro octeto das permissões do arquivo.

chmod 700 teste.sh

E para executá-lo, podemos passar o caminho absoluto ou simplesmente:

./teste.sh

Mas o que são esses "octetos"?

Permissão de arquivos Linux

O básico das permissões de arquivos em Linux são as permissões para ler, escrever e executar. Um octeto corresponde a 3 bits, indo de 0 à 7:

111

Sendo da esquerda para a direita:

4, 2, 1

Agora, da esquerda para a direita temos:

r - para leitura.

w - para escrita.

x - para execução.

Podemos simplesmente exeuctar:

chmod u+x teste.sh

Mas aí você estaria preso ao conhecimento superficial das permissões.

As permissões padrão do Linux tem 3 octetos; o primeiro é o proprietário do arquivo. O segundo é o grupo e o terceiro é outros. Vamos deixar que o grupo possa ler e modificar o nosso script e que os outros apenas possam ler o conteúdo. Para tal:

chmod 764 teste.sh

Para ver como estão as opções, basta utilizar o comando ls -l teste.sh:

Nessa última imagem temos as permissões, número de links, o proprietário, o grupo, o tamanho, mês, dia, hora e nome do arquivo. Nos atenhamos às permissões.

O primeiro campinho ("-") muda quando se trata de diretório, link simbólico, dispositivo de bloco etc. Seguidamente, as permissões de proprietário, grupo e outros. O dono tem rwx, o grupo tem rw**-** e outros não tem nada (---). O proprietário é djames. Nesse caso específico, o grupo também se chama djames. Mas são coisas distintas. Os outros pode ser qualquer usuário cadastrado em /etc/passwd.

Com isso você já sabe criar o script shell, já sabe controlar as prmissões e já sabe executar. Agora vamos adicionar diálogo ao script para, por exemplo, pegar o IP da interface wireless, a wlan0. Mas para isso, vamos ver antes dois outros comandos.

egrep e awk

O comando egrep é um grep avançado, para utilizar com expressões regulares. Não vou escrever sobre expressões regulares, esse também é um assunto muito extenso e que varia até de um shell para outro, ainda mais em linguagens de programação como C++, Qt, Python etc.

O awk é um comando poderoso, que serve para uma enormidade de coisas, mas basicamente estou o utilizando aqui para capturar um determinado campo separado por espaços ou tabs.

O que vamos fazer aqui é listar a interface, pegar a linha que nos interessa, remover a linha que não nos interessa e exibir apenas o campo contendo o endereço IP. Veja na imagem a seguir essa série de passos:

Agora que já sabemos como pegar o IP, vamos guardá-lo em uma variável. Para isso, devemos utilizar a crase para proteger o comando. As crases indicarão que a variável conterá apenas o resultado da expressão utilizada acima:

LOCAL_IP=`ifconfig wlan0|egrep inet|egrep -v inet6|awk '{print $2}'`

Não devemos utilizar espaços precedentes ou procedentes ao sinal de igualdade. Obrigatoriamente deve-se "colar" a variável e o comando ao sinal de igualdade. Está claro? Ok, agora vamos compor um comando para pegar o IP público.

dig

Lembra que lá em cima instalamos o pacote dnsutils? Uma das ferramentas oferecidas nesse pacote é o comando dig. Aqui o utilizaremos para pegar o IP público que utilizamos para acessar a Internet através do Raspberry:

dig +short myip.opendns.com @resolver1.opendns.com

Mais uma vez, devemos guardar a saída em uma variável. Já temos os comandos para descobrir nossos IPs, sem precisar pedir ao usuário que faça o diagnóstico: "Seu Raspberry pegou IP na sua rede? Qual é seu IP público para que eu possa fazer acesso remoto?".

Função em shell script

Para criar uma função em shell script, simplesmente a declaramos dessa maneira:

hello(){
    echo "Hello World"
}

hello

Para chamá-la, basta colocar seu nome, como exemplificado acima. Vamos fazer um menu com duas funções; mostrar o IP local e o IP público:

#!/bin/bash

myIP(){
    MY_IP_IS=`dig +short myip.opendns.com @resolver1.opendns.com`
    SIZE=`echo $MY_IP_IS|wc -c`
    [ $SIZE -lt 6 ] && MY_IP_IS="Sem retorno"
    dialog --stdout --title "IP publico" --msgbox "$MY_IP_IS" 0 0
}

myLocalIP(){
    MY_LAN_IP=`ifconfig wlan0|egrep inet| egrep -v inet6|awk '{print $2}'`
    SIZE_LAN_IP=`echo $MY_LAN_IP|wc -c`
    [ $SIZE_LAN_IP -lt 5 ] && MY_LAN_IP="Sem IP local"
    dialog --stdout --title "IP local" --msgbox "$MY_LAN_IP" 0 0 
}

Acima, utilizei o comando wc, que serve para contar linhas ou caracteres. Estou considerando um número mínimo para indicar se há ou não um endereço IP. Claro que dá para melhorar a avaliação, mas isso é um exemplo básico, lembre-se.

As funções estão prontas. Agora vamos criar o menu e avaliar a escolha do usuário.

Menu em Dialog com Raspberry

Seguidamente às funções, criaremos o menu, que se executará em um loop infinito. Cada item é composto pelo par chave**/info**:

while true; do
    RES=$(dialog --stdout --title "Analise de IP" --nocancel --menu "Seta para selecao (^v), [Tab] para botao" 0 0 0 \
    publico 'Mostra o IP publico' \
    privado 'Mostra o IP privado' \
    sair 'Sai desse menu')

    case $RES in
        publico) myIP ;;
        privado) myLocalIP ;;
        sair) break ;;
    esac
done

O loop em shell script é um pouquinho diferente do habitual em linguagens de programação, provavelmente causará estranheza. Mas basicamente é um conjunto while <condição>; do; done. Já para o case o formato é case <condição> in <opção>/ação; esac.

Colocando tudo junto temos:

#!/bin/bash

myIP(){
    MY_IP_IS=`dig +short myip.opendns.com @resolver1.opendns.com`
    SIZE=`echo $MY_IP_IS|wc -c`
    [ $SIZE -lt 6 ] && MY_IP_IS="Sem retorno"
    dialog --stdout --title "IP publico" --msgbox "$MY_IP_IS" 0 0
}

myLocalIP(){
    MY_LAN_IP=`ifconfig wlan0|egrep inet| egrep -v inet6|awk '{print $2}'`
    SIZE_LAN_IP=`echo $MY_LAN_IP|wc -c`
    [ $SIZE_LAN_IP -lt 5 ] && MY_LAN_IP="Sem IP local"
    dialog --stdout --title "IP local" --msgbox "$MY_LAN_IP" 0 0 
}

while true; do
    RES=$(dialog --stdout --title "Analise de IP" --nocancel --menu "Seta para selecao (^v), [Tab] para botao" 0 0 0 \
    publico 'Mostra o IP publico' \
    privado 'Mostra o IP privado' \
    sair 'Sai desse menu')

    case $RES in
        publico) myIP ;;
        privado) myLocalIP ;;
        sair) break ;;
    esac
done

O resultado é similiar à imagem de destaque (com bem menos recursos, claro). Pegue o código, brinque e estude um pouco de shell script e dialog. Em 2005 fiz um sistema operacional de clonagem chamado PhantomSystem, para substituir o então tradicional Ghost. O sistema fez um sucesso incrível, atendia melhor que o Ghost, quebrava senha de BIOS, de Windows, de Linux, clonava local, em sistema de arquivos em rede, fazia boot do pendrive, CD, pela rede e mais um monte de recursos que já não lembro mais. Suas versões iniciais eram totalmente em Dialog e o sistema operacional inteiro tinha apenas 7MB! Não subestime shell script, com certeza lhe fará economizar muitas horas de desenvolvimento para resolver tarefas complexas!

  Inscreva-se no nosso canal Manual do Maker no YouTube.

Também estamos no Instagram.