200px-Wi-Fi_Logo.svg

Listando as redes wi-fi usando Python

No post de hoje, vou ensinar a listar as redes wi-fi usando python ao invés de comandos do shell. Você deve estar se perguntando: “Mas pra quê?” Bueno, você poderia criar uma pequena aplicação que gerencia duas redes wi-fi, escolhendo a com sinal mais forte e se conectando a ela. Ou, listar as redes wifi de um computador remotamente, e por ai vai.

Para isso vamos utilizar a biblioteca wifi, que nada mais é que um wrapper para o iwlist e o arquivo /etc/network/interfaces.

Instalando a biblioteca

A instalação é muito simples, basta o usar o pip:

$ sudo pip install wifi

Se você ainda não conhece o pip, tem uma apresentação no slideshare que apresenta muito bem a ferramenta. (http://www.slideshare.net/pugpe/pip-5939243)

Utilizando para listar as redes ao alcance

Bora programar! Abra o shell do python como root (ou com previlégios usando o sudo, se não o fizer assim não vai funcionar) e digite o seguinte:

from wifi import Cell
cells = Cell.all('wlan0')
for cell in cells:
    print cell.ssid

Inicialmente importamos a classe Cell, que é  o wrapper, de fato, do iwlist. Em seguida, solicitamos os output do iwlist através do método all. Esse método retorna uma lista de objetos, cada um representando uma rede que o iwlist encontrou. O parâmetro que passamos ao all é uma string com o nome da sua interface wifi – Para descobrir qual o nome da sua, use o iwconfig no terminal.

Esses objetos tem diversos atributos, cada qual representa uma informação sobre cada rede. No nosso exemplo, o atributo ssid é o “nome” da rede. Há vários outros que nos revelam informações interessantes sobre as redes ao nosso arredor, para os conhecer, dê uma olhada na documentação da biblioteca.

Listando a rede e a sua potência

No próximo programinha, vamos atribuir a cada rede, a potência que o nosso adaptador de rede mediu. Em seguida, vamos classificar em ordem do sinal mais forte para o mais fraco, indicando a “melhor” rede.

from wifi import Cell

cells = Cell.all('wlp2s0')
cell_power = []

for cell in cells:
    cell_power.append((cell.ssid, cell.signal))

cell_power.sort(key=lambda cell_signal:cell_signal[1], reverse=True)

print cell_power

A iteração do laço, adicionamos um tuple a lista cell_power. Em seguida, utilizamos o método sort para ordenar essa lista, usando como critério o segundo elemento do tuple que criamos no laço.

NOTA: Se estiver com alguma dúvida em relação ao lambda, 
dê uma olhadinha nesse link que você vai entender. :D

Muito bem, apresentamos a pequena biblioteca wifi e colocamos dois exemplinhos para ajudar. Espero que isso ajude você algum dia! Até a próxima!

Bottle: IoT fácil na Raspberry Pi com Python

A Internet das Coisas (IoT, na sigla em inglês) é onda do momento no mundo Maker. E colocar nossas “coisas” na rede está ficando cada vez mais fácil. Neste artigo, vou ensinar como utilizar o Bottle para colocar a Raspbery Pi como um servidorzinho web e servir dados a outros dispositivos através da rede, ou mesmo, controlá-la via web.

O pacote Bottle
O Bottle[1] é uma micro framework web para Python. O projeto é open-source, e seu código-fonte, sob licensa MIT, está disponível no Github[2].

Uma das coisas mais legais que eu achei do Bottle, é que ele é distribuído em um único arquivo .py, e a única dependência é a Python Standard Librarie.

HelloBottle
Para nos familizarmos com a framework, nada melhor que o bom e velho HelloWorld (a.k.a HelloBottle). Mas antes de mais nada, vamos criar um diretório de trabalho e baixar o bottle:

$ mkdir hello_bottle
$ cd hello_bottle
$ wget https://github.com/bottlepy/bottle/raw/master/bottle.py

Através do download direto, baixamos a versão mais recente do bottle, com o ônus de ela poder ser um pouco instável. Se você se preocupa com isso, instale-o através do pip ou do easy_install.

Ótimo, com o pacote em mão podemos podemos prosseguimos para o código:

from bottle import run, route

@route("/hello")
def test_bottle():
	return "<b>Olá mundo!</b>"

run(host="0.0.0.0", port=8080)

Na primeira linha,

from bottle import run, route

do pacote bottle, importamos as funções run e route.

No trecho,

@route('/hello')
def test_bottle():
	return "<html><body><b>Olá mundo!</b></body></html>"

Definimos que ao chamarmos o http://:/hello executaremos a função test_bottle. O client receberá a string retornada da função, que nada mais é que uma página html.

A função run(),

run(host="0.0.0.0", port=8080)

é responsável por rodar o nosso servidorzinho. O parâmetro “host” indica qual o endereço que o servidor escutar. Passando 0.0.0.0 indicamos que qualquer endereço pode acessar nosso servidor. Se você pusesse 127.0.0.1, você só conseguiria acessar o servidor a partir da própria Raspberry, o que é interessante somente para testes. Já o parâmetro “port”, define qual porta o servidor escuta, no caso, a porta 8080.

Para rodar o nosso teste, salve o arquivo hello_bottle.py com o código acima, e digite no terminal:

$ python hello_bottle.py

em outra instância do terminal, descubra o endereço ip da sua Raspberry, digitando:

ifconfig eth0

Abra um browser em outro computador na mesma rede e digite na barra de endereços, substituindo 10.0.0.110 pelo endereço da sua Raspberry:

http://10.0.0.110:8080/hello

No browser , você deve ler Olá Mundo!.

Conversando com o servidor: Pegando a temperatura da CPU
A idéia não é ficar retornando páginas html, mas sim dados que possam ser manipulados por outros servidores, páginas dinâmicas ou por um app em um celular. Para isso, quando requisitado, ao invés de retornar uma string com um código html, vamos retornar dados no formato JSON[3]. Nesse formato, os dados são melhor manipuláveis e podem ser integrados a páginas dinâmicas(AJAX) e tudo mais.

No próximo exemplo, vamos ler a temperatura da CPU da Raspberry, e retornar em formato JSON para que possa ser lida por outras aplicações.

from bottle import route, run, response
import json

@route("/temperature")
def getTemperature():
        file = open("/sys/class/thermal/thermal_zone0/temp","r")
        cpu_temp = int(file.read())/1000.0
        file.close()

        response.content_type = "application/json"
        cpu_temp_json = json.dumps({"temperature":str(cpu_temp)})

        return cpu_temp_json

if __name__ == "__main__":
        run(host='0.0.0.0', port=8080)

No código acima, percebemos uma mudança, em relação ao “hello world” do código anterior, já nas duas primeiras linhas:

from bottle import route, run, response
import json

veja que importamos mais dois objetos: response do pacote bottle e o json, que é nativo.

Em seguida, definimos a função getTemperature():

@route("/temperature")
def getTemperature():
        file = open("/sys/class/thermal/thermal_zone0/temp","r")
        cpu_temp = int(file.read())/1000.0
        file.close()

        response.content_type = "application/json"
        cpu_temp_json = json.dumps({"temperature":str(cpu_temp)})

        return cpu_temp_json

Primeiro, abrimos o arquivo temp, localizado em /sys/class/thermal/thermal_zone0/, para leitura. Na linha seguinte, dividimos o valor lido por 1000, e o resultado será o valor da temperatura da cpu em grau Celsius.

As três linhas seguintes determinam o tipo de resposta que o servidor entregará ao cliente:

response.content_type = "application/json"
cpu_temp_json = json.dumps({"temperature":str(cpu_temp)})

return cpu_temp_json

Primeiro, setamos o tipo de resposta para “application/json” através do response.content_type. Segundo, gravamos na variável cpu_temp_json, o resultado da serialização da temperatura com uma chave(json key) chamada “temperature”. Em seguida, retornamos cpu_temp_json. Assim, quando fizermos a requisição através do endereço http://10.0.0.110:8080/temperature, a resposta será do tipo JSON.

json

E agora?

Bueno, a partir daqui você já pode sair controlando a sua Raspberry Pi através de sua rede local. Com um pouco de configuração em seu roteador será possível controla-lá não só na rede local, mas através da internet também. Vale a pena dar uma pesquisada.

Que tal controlar o I/O, ler um sensor, ou mesmo rebootar sua Rasp pela rede? Legal, né?Mas isso é assunto para outros posts… Até lá! :)

Referências:
[1] http://bottlepy.org/docs/dev/index.html
[2] https://github.com/bottlepy/bottle
[3] http://json.org/

Configurar a identação do Vim

Para configurar a identação do Vim para quatro espaços ao invés do “default” de 8 espaços, basta digitar o seguinte:

:set tabstop=4

Se tu reiniciares o Vim, perceberás que a identação volta ao padrão. Para tornar a mudança permanente, :basta editar (ou criar) o arquivo .vimrc na sua “home” e inserir o texto:

set tabstop=4

fonte: http://stackoverflow.com/questions/1878974/redefine-tab-as-4-spaces

Configuração headless da Raspberry Pi

O post de hoje é uma dica pra quem quer usar a Raspberry pi e não tem um monitor ou uma TV com hdmi sempre disponível. Aqui em casa, por exemplo, eu preciso liberar a TV pra minha esposa poder assistir a novela! :p

Configuração da Raspberry Pi

Primeiro, vamos instalar o x11vnc na rpi (eu uso a distro raspbian) que é um servidor VNC:


sudo apt-get install x11vnc

Após instalar o servidor de vnc, vamos configurar a resolução da rpi:


sudo nano /boot/config.txt

Descomente as linhas (removendo o ‘#’ do incio da linha):


disable_overscan=1

hdmi_force_hotplug=1

hdmi_group=1

hdmi_mode=1

Substitua o valor dos campos hdmi_group e hdmi_mode para os seguintes:


hdmi_group=2

hdmi_mode=28

Com essa configuração habilitamos a rpi a usar a resolução 1280×800@60Hz, que é a resolução do meu PC. Você pode escolher outra mais apropriada a resolução do seu PC, para tal sugiro que consulte a tabela do elinux.

Se tu ainda não fizeste, habilite a rpi para chamar a interface gráfica já no boot:


sudo raspi-config

Selecione a opção 3: “Enable Boot to desktop” e na próxima tela selecione “yes”.

Finalmente, configure o LXDE (o window manager) para subir o x11vnc junto com ele. Para tal, siga os passos a seguir:


mkdir -p ~/.config/lxsession/LXDE/

echo "@x11vnc -forever" > ~/.config/lxsession/LXDE/autostart

A opção “-forever” indica que o após desconectar, o servidor deve continuar rodando.

Configuração do PC

No teu pc, tu vais precisar apenas de um cliente VNC. No Fedora 18, eu instalei o Remmina e o plugin dele para conectar a servidores VNC:


sudo yum install remmina remmina-plugins-vnc -y

A interface do remmina é bastante intuitiva, para configurar uma nova conexão basta clicar no icone do folha de papel com um “+”.

remmina

Na tela que surge, complete o campo server é o mais importante, insira ai o endereço IP da Rpi (para descobrir digita no terminal da rpi: ifconfig eth0 e copia o valor do campo ipaddr).

remmina_editor

Clique em Connect e pronto! A tela da tua Raspberry Pi deve surgir em uma janela!

Agora é só hackear e programar ( e deixar tua TV livre!) ^^

FONTES:

http://www.raspberrypi.org/phpBB3/viewtopic.php?f=26&t=19600

http://elinux.org/RPiconfig

https://wiki.archlinux.org/index.php/LXDE#autostart_file

Aprendendo gratuitamente a programar na web, é possível?

Buenas indiada!

Sabia que é possível aprender e se profissionalizar na internet? Melhor ainda: gratuitamente?! Eu reuni alguns links que eu já utilizei para estudar( ou não) com aulas de linguagens de programação, sistemas embarcados, eletrônica e por ai vai. Por que nem só de Facebook vive o nerd!

Linguagens de programação

Ultimamente, eu tenho descoberto muita coisa com ajuda do Google e do meu professor de Java (Eduardo “Bisso” @ervcarval) . O próprio Bisso tem um canal super bacana de vídeo-aulas de Java no Youtube, onde ele ensina o os fundamentos da linguagem e o uso de algumas ferramentas através do desenvolvimento de um projeto.

Se Java não é o que tu procuras, que tal Python? Eu utilizei muito um livro brasileiro e grátis, o “Python para desenvolvedores, 2a edição” O foco dele não são os noobs em programação, mas quem já sabe programar e quer aprender Python (que por sinal, é uma ótima linguagem!).

Pra galera mais hardcore, baixo nível mesmo, eu recomendo o site do Alex Allain o http://www.cprogramming.com que tem tutoriais e posts sobre C/C++ do mais básico e fundamental ao recursos mais avançados. Ele publicou um livro recentemente, mas infelizmente não é grátis… :(

Academia de programação

Durante as pesquisas para escrever este post, eu achei uma ferramenta muito tri.. Não, muito mais que isso: Realmente Punk! O Code Academy! O CA surgiu no final de 2011 e na primeira semana de vida já tinha 200.000 alunos! Na minha singela opinião, o sucesso se deve ao formato de EAD de programação apresentado por eles, que eu acredito ser o futuro desse tipo de plataforma. Funciona assim: Tu te cadastra, ou usa tua conta das redes sociais, e já sai programando, no browser mesmo… Simples assim! A página apresenta um fundamento da linguagem no lado esquerdo, por exemplo declaração de variáveis, e a direita um emulador de terminal para realizar um exercício prático. O resultado sai na hora. A medida que se evolui no curso se ganha medalhas e se pode compartilhar com os amigos nas redes sociais. Há cursos de Javascript, Python, Ruby, JQuery e PHP.

Finalmentes, só que não…

O assunto é muito vasto e há outros cursos e tutoriais sobre esses e outros assuntos relacionados a programação espalhados pela rede. Por exemplo, eu não falei da Softblue oferece um curso de banco de dados gratuitamente, com partes práticas e teóricas, com direito a certificado e tudo mais. Tu podes, ainda, procurar no Youtube por video-aulas e screencast, há vários canais de pessoas e/ou organizações que postam videos realmente legais. Há, ainda, verdadeiras universidades virtuais com o Udacity, o EdX e o Coursera. Enfim, há diversas opções…

Tem sugestões? Acha que eu esqueci de citar algum serviço ou canal? Posta ai nos comentários, vivente!

Nos próximos post vou mostrar que não é só programação que se pode aprender na web.

Até mais!

Criando o ambiente de desenvolvimento da Stellaris Launchpad no Fedora 18 – Parte 1 de 2

A Texas Instruments Stellaris Launchpad é um kit de desenvolvimento para microcontroladores de 32-bit da família Stellaris (agora TivaC) que conta com um núcleo ARM Cortex-M4. O kit é bastante simples e barato (só 12,99 dólares, com frete grátis e impostos pagos), e possui suporte a kit adicionais, chamados BoosterPacks.

No tutorial de hoje, vamos compilar e instalar as ferramentas necessárias para programar e depurar nossas aplicações na Launchpad, e o melhor de tudo: Tudo Free! (Free como em “Free Beer” e como em “Freedom“).

Stellaris Launchap

Bem, como o título já ilustra, este tutorial deve ser seguido por quem quer criar o ambiente no Fedora 18 ou distros baseadas no Red Hat. Se tu usa o ubuntu ou distros baseadas no Debian recomendo seguir o tutorial do blog KernelHacks parte I, parte II e parte III(em inglês).

OK, vamos ao que interessa. As quatro ferramentas necessárias para o desenvolvimento são:

  • A toolchain: GNU ARM Embedded;
  • As bibliotecas: TivaWare;
  • O gravador: lm4f-flash;
  • O depurador: OpenOCD;

Instalando a toolchain – GNU ARM Embedded

A toolchain é o conjunto de ferramentas que nos permitirá compilar nosso código C/C++ e rodá-lo no nosso processador. Perceba que a target é o próprio processador ARM Cortex-M4, sem sistema operacional algum. Chamamos esse tipo de desenvolvimento de Bare Metal Programming.
Primeiro clique aqui e procure por um arquivo com nome (onde XXXXX é o número da versão):

gcc-arm-none-eabi-XXXXX-linux.tar.bz2

Esse arquivo contém os binários da toolchain para o sistema operacional GNU/Linux (independente da distribuição).

Agora vamos extrair o conteúdo do arquivo. Para isso abra uma o emulador de terminal, por exemplo o gnome-terminal ou o xterm e digite o seguinte:
(lembrete: o símbolo $ significa que o comando deve ser rodado como usuário comum)

$ tar jxvf gcc-arm-none-eabi-XXXXX-linux.tar.bz2

Um diretório com o nome gcc-arm-none-eabi-XXXXX deve ter sido criado.

Eu costumo instalar aplicações que não são fornecidas pelos repositórios da minha distro no diretório /opt, ao menos que você saiba o que está fazendo, recomendo que faça o mesmo.
Então, copie o diretório gcc-arm-none-eabi-XXXXX para o diretório /opt :
(lembre-se uqe o # indica que o comando deve ser executado com privilégios de super usuário – root)

# cp -r gcc-arm-none-eabi-XXXXX /opt/gcc-arm-none-eabi
# chown -R <usuario_normal>:<usuario_normal> /opt/gcc-arm-none-eabi

Por fim, vamos adicionar o caminho com as ferramentas à variável de ambiente PATH:

$ export PATH=$PATH:/opt/gcc-arm-none-eabi/bin

Para testar se tudo ocorreu como esperado digite no terminal:

$ arm-none-eabi-cpp --version

A reposta no terminal deve ser algo como:

arm-none-eabi-cpp (GNU Tools for ARM Embedded Processors) 4.7.3 20130312 (release) [ARM/embedded-4_7-branch revision 196615]
Copyright (C) 2012 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Instalando as Bibliotecas – TivaWare
O TivaWare é uma biblioteca para acessar os periféricos e outros recursos dos processadores da família TivaC (compatível com os Stellaris LM4F). Clique aqui e baixe o arquivo SW-TM4C-X.X.exe (a versão no dia 31/8/2013 era 1.1). Será necessário preencher um cadastro e concordar com alguns termos.

Após realizar o download, vá ao terminal e descompacte o arquivo.

$ mkdir TivaWare
$ unzip SW-TM4C-1.1.exe -d TivaWare

Em seguida, compile a biblioteca com a toolchain que configuramos no passo anterior.

$ cd TivaWare
$ make

Compilando e instalando o LM4F-Tools e o OpenOCD

Se você chegou até aqui, já pode criar seus próprios códigos, compilá-los e tals. Maaaas, e testar? Ver eles rodando na target mesmo? Hum… Falta pouco! Vamos instalar o OpenOCD e o LM4F-Tools. Para isso vamos baixar algumas dependências:

# yum install flex bison gmp-devel mpfr-devel libmpc-devel ncurses-devel git libc-devel make gcc libyaml-devel PyYAML libusbx libusbx-devel git

Feito?! Ótimo! Agora vamos clonar o repositório do LM4F-Tools. Esse conjuntinho de ferramentas possui uma ferramenta específica que é de nosso o interesse: o LM4F-Flash. Este programinha bem simples serve para gravarmos o nosso programa no microcontrolador.

git clone https://github.com/utzig/lm4tools.git

Agora vivente, vamos baixar a última versão do OpenOCD(no dia desta publicação era a 0.70, a primeira a ter suporte a interface ICDI da Stellaris/Tiva). Acesse o site http://sourceforge.net/projects/openocd/files/openocd/0.7.0/ e faça o download do arquivo .tar.gz e em seguida descompacte-o:

$ tar zxvf openocd-0.7.0.tar.gz
$ cd openocd-0.7.0

Agora vamos compilá-lo e partir pro abraço:

$ ./configure --prefix=/opt/openocd --enable-ft2232_libftdi --enable-ep93xx --enable-at91rm9200 --enable-usbprog --enable-presto_libftdi --enable-jlink --enable-vsllink --enable-rlink --enable-dummy --enable-gw16012 --enable-amtjtagaccel --enable-ti-icdi
$ make
# make install

Agora temos o ecossistema prontinho para brincarmos com a nossa launchpad. No próximo post vamos piscar um led nela, até lá! =)

Saga Aparência do Eclipse Juno no Fedora Linux – Parte II

Bueno, continuei invocado com a aparência do Eclipse Juno no Fedora, tinha esquecido como eram gigantes os títulos das abas (ali onde diz Package Explorer, Task List, nome dos arquivos fontes e etc..). Achei uma solução macanuda aqui!

Edite o arquivo e4_default.css, ele fica em:

/eclipse/plugins/org.eclipse.platform_4.2.2.v201302041200/css

Procure pela seção .MPartStack e edite onde diz font-size, troque de 11 para 9 e aproveite!