!

!
! Universidade de So Paulo
!
! Escola de Engenharia de So Carlos
!
!
!
!
!
!
!
Relatrio de Iniciao Cientfica:

Desenvolvimento de um porteiro eletrnico

interativo automatizado via web

Aluno: Giuliano Barbosa Prado

Nmero USP: 7961109

Orientador: Professor Doutor Evandro Luis Linhari Rodrigues

!
So Carlos

2013

!
!
!
!
Pgina 1
ndice

Introduo! 3!
Objetivos! 3!
Metodologia e materiais utilizados! 4!
Cronograma! 5!
Resultados! 6!
Concluso! 12!
Bibliografia! 13!

!
!

Pgina 2
Introduo
Sobre a arquitetura ARM
A arquitetura ARM (Advanced RISC Machines) trouxe um grande avano na soluo de
problemas em sistemas embarcados. Ela traz como caractersticas bsicas a simplicidade
e o baixo consumo de energia. Isso causou a popularidade e expanso dessa arquitetura,
hoje usada em diversos gadgets, como dispositivos portteis e celulares e at meios de
transporte, a exemplo de computadores de bordo em automveis. Assim, utilizando os
conceitos adquiridos nos projetos e trabalhos executados anteriormente no laboratrio,
esse projeto teve como objetivo continuar o desenvolvimento de sistemas Linux
embarcados, aplicando e desenvolvendo sistemas de streaming de vdeo embarcado,
utilizao de sada GPIO e controle de uma IPCam. O sistema operacional escolhido foi o
Linux devido ao fato de ser gratuito, opensource e estvel.

!
Objetivos
Sobre os objetivos do projeto
Desenvolver habilidades na utilizao do sistema operacional GNU/Linux em sistemas
embarcados

Aprender sobre a arquitetura ARM

Aprender sobre procedimentos de compilao de um Kernel

Criar e instalar um sistema de arquivos baseado na distribuio Debian

Conhecer os procedimentos necessrios para usar sadas GPIO para emitir sinais de
sada

Desenvolver um sistema para streaming de vdeo via web

Desenvolver um sistema web seguro para exibir imagens e controlar uma IPCam

Pgina 3
Metodologia e materiais utilizados
Procedimentos adotados no projeto
Para a parte inicial, foi utilizado o kit SAM9-L9260 da Olimex, que possui como atributos
um microcontrolador ARM9 de 32 bits, 64MB de memria RAM e 512MB de memria
flash.

Na segunda parte, foi utilizado o kit Tiny6410 da FriendlyARM, com um microcontrolador

ARM11 de 32 bits, 256MB de memria RAM e 2GB de memria flash. Esse sistema foi
escolhido por possuir um processamento superior para a aplicao desenvolvida e por
apresentar, tambm, conectores adequados para o projeto, como sada e entrada de
udio e uma quantidade superior de portas USB.

Para tanto, foi compilado e desenvolvido um Kernel Linux para a o kit inicial e utilizado
um fornecido pelo fabricante para o segundo.

Aps a instalao e configurao do Kernel, do sistema operacional e das ferramentas

bsicas, o projeto voltou-se para o desenvolvimento de um sistema de comunicao e
controle de sadas GPIO. Todo esse procedimento est descrito detalhadamente no
captulo de resultados.

Alm disso, foi utilizado uma webcam wireless com movimento integrado para a parte
final do projeto.

!
!

Pgina 4
Cronograma
Resumo do calendrio adotado no programa
!

Inicio das atividades Maro / 2013

Aperfeioamento em UNIX Maro / 2013

Configurao e compilao de Kernel Abril-Maio / 2013

Configurao de Sistema de Arquivos Junho / 2013

Desenvolvimento de aplicativo GPIO para Junho / 2013

SAM9-L9260
Inicio do uso da Tiny6410 Julho / 2013

Desenvolvimento de aplicativo GPIO para Agosto / 2013

Tiny6410
Configurao de rede Agosto-Setembro / 2013

Instalao e configurao do servidor Setembro / 2013

Apache
Uso do FFMPEG e transmisso de fotos Setembro-Outubro / 2013

Preparao para o SIICUSP Outubro / 2013

Uso de MJPG-Streamer e transmisso de Novembro / 2013

vdeo
Incio do uso da IPCam Novembro / 2013

Desenvolvimento de aplicativo para Dezembro / 2013

controle da IPCam
Encerramento do projeto Dezembro / 2013

!
!

Pgina 5
Resultados
Resultados obtidos durante o programa
Inicialmente, o projeto focou-se no aperfeioamento no uso de sistemas embarcados e
numa melhor compreenso de seu funcionamento. Para tal, foi aperfeioado o uso do
terminal e das ferramentas UNIX, o que apresentou grande relevncia para o projeto em
geral.

Em seguida, iniciou-se o trabalho com o Kernel do Linux. Para isso, foi efetuado o
download da verso do Kernel Linux mais atual disponvel no momento do projeto1. Para

a configurao, foram utilizadas ferramentas grficas como XConfig e MenuConfig.

Nesse processo, foram estudados todos os requisitos do sistema embarcado em uso e

efetuada a ativao apenas dos mdulos que se mostravam mais necessrios, visando a
otimizar o sistema e construir um Kernel que fosse suportado pela placa (isto , que
tenha tamanho de at 1.5MB).

Com os devidos mdulos escolhidos, o comando make era utilizado para efetuar a
compilao do kernel, gerando um arquivo denominado uImage. Esse arquivo era
transferido utilizando a entrada serial da placa, conectada a um computador, e o
software Tera Term era executado para monitoramento, o que permitia visualizar
eventuais erros para futuras correes.

Por fim, alcanou-se o objetivo esperado nessa etapa e foi compilado um kernel
otimizado e funcional para o sistema embarcado.

Aps a construo do Kernel, iniciou-se a configurao e instalao de um sistema

operacional Debian. Esse sistema foi escolhido por ser leve e pratico, alm de existir
documentao de trabalhos anteriores2 com ele no laboratrio. Para tanto, inicialmente

foi instalado o Debootstrap em um computador. Em seguida, foi feito o download do

Debian3 e emulado usando qemu. Durante o uso da verso emulada no computador, eram

instalados os aplicativos necessrios para o futuro uso do sistema operacional. Esses

procedimentos esto ilustrados abaixo no quadro 1.

1 https://www.kernel.org
2 http://opencore.eesc.usp.br
3 http://sft.if.usp.br/debian/
Pgina 6
 mkdir Debootstrap
cd Debootstrap
apt-get install binfmt-support qemu qemu-user-static debootstrap
sudo debootstrap --foreign --arch armel wheezy debian_armel_wheezy http://sft.if.usp.br/
debian/
sudo cp /usr/bin/qemu-arm-static debian_armel_wheezy/usr/bin
sudo chroot debian_armel_wheezy/
dpkg --force-all -i /var/cache/apt/archives/*.deb
aptitude install locales
dpkg configure -a
nano /etc/hostname
!

Quadro 1 - Procedimento para download do sistema de arquivos Debian

!

Com o Kernel e o sistema de arquivos instalados, iniciou-se a configurao e uso do ssh

para controle remoto da placa. Para isso, foi utilizado o aplicativo apt-get, nativo do
Debian, para efetuar o download, e em seguida foram feitas as devidas configuraes.

O passo seguinte do projeto consistiu no desenvolvimento de aplicaes para uso das

portas GPIO. Para tanto, foi desenvolvido um mapeamento em memria dessas sadas.
Utilizando a linguagem C, foram escritos aplicativos que utilizavam as portas GPIO,
assim como o controle dos LEDs, similares ao exemplo do quadro 2. Nesse procedimento,
eram definidos os pinos a serem utilizados nos registradores Enable e OutputEnable, e
em seguida utilizado o registrador de dados (Data).

Terminada essa parte do projeto, iniciou-se a migrao para o kit Tiny6410, da

FriendlyARM. Essa mudana findou-se na necessidade de maior processamento para a
utilizao de imagens, alm de entradas e sadas de som e entradas USB adicionais.

Nesse processo, utilizou-se o Kernel fornecido pelo fabricante, visto que essa verso
atendia a todos os requisitos necessrios para a aplicao.

Alm disso, foi instalada uma verso do Xubuntu no dispositivo, devido ao fato de essa
distribuio ter uma verso otimizada e configurada pelo fabricante para a placa. Para
tal procedimento, utilizou-se a memria flash fornecida com o kit, e, na chave seletora
do dispositivo, foi escolhida a opo de instalao, conforme instruo do fabricante4.

Em seguida, bastou seguir as recomendaes no dispositivo e finalizar com a instalao.

4 http://www.friendlyarm.net/downloads#manuals
Pgina 7
Com o trmino da instalao do sistema operacional, procedeu-se com a configurao da
rede. Para isso, foram editados os IPs na interface da rede, o script 70-persistent-
net.rules e a inicializao do Xubuntu, conforme quadros 3, 4 e 5.

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

!
#include <unistd.h>

int main (int argc, char *argv[]) {

setuid(0);
int i;
int opcao=0;
// Le a memoria
int memfd = open("/dev/mem", O_RDWR);
// Mapeamento da memoria a partir de 0xfffff000
void *a = mmap(0, 4*1024, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, memfd, 0xfffff000);
// Se nao mapear, retorna erro
if ((int) a == -1) {
perror("Erro no mmap\n");
exit (1);
}
// enable no PIOA, pino 6
*(unsigned int*)(a+0x400)=0x40;
// output enable no PIOA, pino 6
*(unsigned int*)(a+0x410)=0x40;

while (opcao!=4){
printf("-------------------\n\nSelecione uma opcao: \n\n1- Ligar LED\n2- Desligar LED\n3- Piscar 20 vezes\n4- Sair \n\n>
Opcao:");
scanf("%d",&opcao);
if (opcao==2)
{
// acende PIOA6
*(unsigned int*)(a+0x430)=0x40;
}
if (opcao==1)
{
// apaga PIOA6
*(unsigned int*)(a+0x434)=0x40;
}
if (opcao==3)
{
for (i=0;i<10;i++)
{
*(unsigned int*)(a+0x430)=0x40;
usleep(500000);
*(unsigned int*)(a+0x434)=0x40;
usleep(500000);
}
}
}
// output disable no PIOA, pino 6
*(unsigned int*)(a+0x414)=0x40;
// disable no PIOA, pino 6
*(unsigned int*)(a+0x404)=0x40;
// Fecha a memoria
close(memfd);
return 0;
}
!

Quadro 2 - Exemplo de mapeamento em memria

!
Pgina 8
Assim, conectado com a rede, pde-se iniciar o trabalho na transmisso de imagens via
internet. Procedeu-se com a instalao do servidor Apache5 para a hospedagem de um

site visando o streaming de imagens online.

auto lo
iface lo inet loopback
iface eth0 inet static
address 10.235.0.142
netmask 255.255.252.0
network 10.235.3.0
gateway 10.235.0.1
pre-up ifconfig eth0 hw ether 00:01:02:03:05:14
dns-nameservers 143.107.225.6 143.107.182.2 8.8.8.8
!

Quadro 3 - /etc/network/interfaces
!

# This file maintains persistent names for network interfaces.

# See udev(7) for syntax.
#
# Entries are automatically added by the 75-persistent-net-generator.rules
# file; however you are also free to add your own entries.
# net device ()
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="00:01:02:03:05:14",
ATTR{dev_id}=="0x0", ATTR{type}=="1", KERNEL=="eth*", NAME="eth0"
!

Quadro 4 - /etc/udev/rules.d/70-persistent-net.rules
!

cp /etc/udev/rules.d/70-persistent-net.rules-backup /etc/udev/rules.d/70-persistent-
net.rules
/etc/init.d/networking restart
ifup eth0
/etc/init.d/ssh restart
!
Quadro 5 - /etc/init.d/rc - Antes do exit 0!
!
!
Para tal transmisso, inicialmente, utilizou-se o ffmpeg6 . Houve sucesso para a

transmisso de fotos. Porm, devido a eventuais problemas com dependncias e na

compilao de sua verso para ARM, o software foi substituido pelo MJPG-Streamer7, que

j havia sido utilizado em trabalhos anteriores no laboratrio e se mostrou eficaz para a

aplicao esperada, conforme quadro 6.

5 http://www.apache.org
6 http://www.ffmpeg.org
7 http://sourceforge.net/projects/mjpg-streamer/
Pgina 9
 export LD_LIBRARY_PATH=.!
./mjpg_streamer -i "input_uvc.so -y -d /dev/video2" -o "output_http.so -w /var/www/" !
!

Quadro 6 - Uso do MJPG-Streamer, recebendo como parmetro o dispositivo de video (nesse

caso, /dev/video2 (webcam)) e a sada (nesse caso, /var/www (diretrio padro do Apache))
!

Com o fim dessa transmisso, o trabalho voltou-se para o uso de uma cmera IPCam, que
j inclui um sistema de transmisso bsico e um motor para movimento.

Utilizando o dispositivo, iniciou-se o desenvolvimento de uma aplicao para controle do

sistema da cmera. Inicialmente, utilizou-se o navegador para controle do sistema
atravs de uma lista de scripts CGI fornecidos pelo fabricante. Assim, foram
identificados os comandos que movimentavam a cmera e geravam uma fotografia.
A partir desse mapeamento, foi criado um aplicativo em linguagem C para controle
dessas funcionalidades. Esse aplicativo funcionava enviando pedidos para o servidor web
da cmera, que respondia com a devida funo.
Por fim, esse aplicativo foi ampliado e nele foi acrescentado a funo de salvar a foto
em disco, conforme quadro 7. Espera-se o uso daquele para automatizar o movimento da
cmera em futuros trabalhos no laboratrio.

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <arpa/inet.h>
#include <curl/curl.h>
#define IP "143.107.235.59"

!
#define PORT 8085

// COMPILAR COM O PARAMETRO

!
// gcc -lcurl main.c -o test

size_t write_data(void *ptr, size_t size, size_t nmemb, FILE *stream) {

size_t written = fwrite(ptr, size, nmemb, stream);
return written;

!
}

void getFile (char* command, char* outputData)

{
CURL *curl;
FILE *fp;
CURLcode res;
!

Pgina 10
 char *downloadBuffer = malloc((strlen(IP) + strlen(command) + 4 + 9)*sizeof(char));
sprintf(downloadBuffer, "http://%s:%d/%s",IP,PORT,command);
curl = curl_easy_init();
if (curl) {
fp = fopen(outputData,"wb");
curl_easy_setopt(curl, CURLOPT_URL, downloadBuffer);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
curl_easy_setopt(curl, CURLOPT_USERNAME, "admin");
curl_easy_setopt(curl, CURLOPT_PASSWORD, "lavisim");
curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
fclose(fp);
}
}
char *sendCommand(char *command, int printRequest, int printReturn) {
int sockfd = 0, n = 0, count = 0;
char *recvBuff = NULL, *sendBuff;
struct sockaddr_in serv_addr;
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("\n Error : Could not create socket \n");
return NULL;
}
memset(&serv_addr, '0', sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
if(inet_pton(AF_INET, IP, &serv_addr.sin_addr)<=0)
{
printf("\n inet_pton error occured\n");
return NULL;
}
if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
{
printf("\n Error : Connect Failed \n");
return NULL;
}
// cria um GET, que faz login com a senha e acessa a pagina recebida por parametro
sendBuff = (char *) malloc(sizeof(char) * (strlen(command) + 64));
snprintf(sendBuff, sizeof(char) * (strlen(command) + 64), "GET /%s HTTP/1.0\r\nAuthorization: Basic YWRtaW46bGF2aXNpbQ==
\r\n\r\n ", command);
// se solicitado, imprime o pedido a ser enviado
if (printRequest)
printf(%s",sendBuff);

! write(sockfd, sendBuff, strlen(sendBuff));

count = 1;
recvBuff = (char *) realloc(recvBuff, sizeof(char));
// le a resposta do servidor
while ( (n = read(sockfd, &recvBuff[count-1], 1)) > 0)
{
recvBuff = (char *) realloc(recvBuff, sizeof(char) * (count+1));
count++;
}
recvBuff[count-1] = '\0';
free(sendBuff);
// se solicitado, imprime a resposta do servidor
if(printReturn)
printf(%s",recvBuff);
// retorna a reposta do servidor
return (recvBuff);
}
int main(int argc, const char * argv[])
{
sendCommand("decoder_control.cgi?command=6&onestep=1", 0, 0);
getFile("snapshot.cgi","test1.jpg");
return 0;
}
!
Quadro 7 - Aplicativo para controlar a cmera e exemplo de uso (movimento da cmera e foto)!
!

Pgina 11
Concluso
O que se conclui com o projeto
A proposta inicial de automatizar um porteiro eletrnico utilizando um dispositivo
embarcado se mostrou vivel. Entretanto, foi possvel observar que o sistema embarcado
a ser utilizado deve ser escolhido com cautela, visando a satisfazer as necessidades de
processamento e/ou entrada e sada.

Ao concluir esse projeto, foi possvel aprimorar o conhecimento em Linux embarcado e

sobre o funcionamento de um Kernel, bem como sua compilao e configurao
otimizada para a automao.

Foi possvel, tambm, adquirir conhecimentos mais slidos em sistemas operacionais

Linux, com uma maior compreenso de seu funcionamento, suas distribuies e drivers,
com nfase nos sistemas Debian e Xubuntu.

Alm disso, foram exploradas as configuraes de redes e suas portas, permitindo o

melhor entendimento dessas reas. A instalao e configurao de um servidor Apache
tambm foi estudada e melhor compreendidas.

Por fim, foi aperfeioado o uso dos mtodos POST e GET, com o estudo e implementao
de um aplicativo em C para envio de pacotes. Isso permitir que trabalhos futuros no
laboratrio utilizem funes j prontas para controle de cmeras.

Pgina 12
Bibliografia
Fontes de consulta utilizadas no projeto
[1] BLUM, Richard - Linux Command Line and Shell Scripting

[2] PASSOS, L.B.S.; RODRIGUES, E. L. L. Automao usando sistemas operacionais Linux

embarcados em microcontroladores ARM. Iniciao Cientfica LAVISIM 2011.

[3] Projeto OpenCore. http://opencore.eesc.usp.br (acessado 14/01/2014, s 16:25)

[4] The Linux Kernel Archives. http://www.kernel.org (acessado 16/01/2014, s 20:21)

[5] Debian - The Universal Operating System. http://www.debian.org/ (acessado

16/01/2014, s 21:03)

[6] Site do fabricante do kit SAM926, possui manual. http://www.olimex.com/ (acessado

em 18/01/2014, s 19:15)
[7] RODRIGUES, FAUSTO PEREZ; RODRIGUES, E. L. L. Soluo de automao remota
utilizando GNU/LINUX embarcado e o protoloco ZIGBEE/IEEE 802.15.4. Monografia
(Graduao em Engenharia Eltrica com nfase em Sistemas de Energia e Automao) -
Escola de Engenharia de So Carlos, Universidade de So Paulo, So Carlos, 2012.

[8] CURVELLO, ANDR MRCIO DE LIMA; RODRIGUES, E. L. L. Estao de controle

multimdia com interface web utilizando sistema operacional Linux embarcado em
plataforma ARM. Monografia (Graduao em Engenharia de Computao) - Escola de
Engenharia de So Carlos, Universidade de So Paulo, So Carlos, 2012.

Pgina 13