Arquivo da categoria: Informática

Bom o portal amcollucci.com.br, havia nascido com o intuito de falar coisas sobre informática, hoje ele e muito mais abrangente mas não tem como eu abandonar a minha origem!

Comunicação Serial com Arduíno – Parte I

Enviar bits de forma sequencial por um fio ou barramento é chamado de comunicação serial, é um meio muito utilizado para comunicação entre dispositivos. Existem diversas tecnologias de comunicação serial como RS-232, USB, FireWire, Fibre Channel, SCSI dentre outros.

Todas as placas do Arduino possuem ao menos uma porta de comunicação Serial (chamadas de UART  ou USART), nos pinos digitais 0 (RX) e 1 (TX), e boa parte deles pode se comunicar com um computador via USB. Você pode utilizar o Serial Monitor incluído na IDE para escutar diretamente na porta serial.

No meu post “Aprenda a programar o Arduino – Parte 2” dei vários exemplos onde usei a comunicação serial agora pretendo esmiuçar melhor essa comunicação, nesse post vou mostrar como criar um programa que envie dados pela porta serial, e como utilizar o aplicativo PICOCOM, dísponivel para linux para escutar a porta serial e salvar os dados em um arquivo txt.

1 – Instalando o Picocom

sudo apt-get install picocom

2 -Consultar em qual tty o arduino se encontra.

1º Metodo:

    Sem o arduino conectado na USB digitar o comando:

sudo ls /dev/ | grep tty

   Captura de tela de 2013-07-15 22:59:29

     Agora conecte o arduino e digite o mesmo comando, você deve comparar as saídas e verificar qual o tty* apareceu.

Lista de Terminais Virtuais.

     No meu caso o ttyACM0 é o ocupado pelo Arduino.

2º Metodo.

     Na IDE vá em TOOLS> Serial Port> /dev/ttyXXX

3º Metodo

     Conecte seu arduino e digite o seguinte comando

dmesg | grep tty

Captura de tela de 2013-07-15 23:06:45

Agora vamos a um exemplo simples.

Na IDE do arduino digite o seguinte programa, e grave no microcontrolador

void setup(){
Serial.begin(9600);
}

void loop(){
Serial.println(“Aprendendo a usar Serial”);
}

 

Então abra um terminal em seu linux e digite:

picocom /dev/ttyXXXX

 

Para sair use CTRL + A + X

A grande vantagem em relação ao serial monitor nativo da IDE esta na possibilidade de enviar a saída do comando para um arquivo ou concatenar com outro comando linux, como no exemplo abaixo:

picocom /dev/ttyXXXX >> /home/teste.txt

 

Em breve continuo com mais informações.

Fontes Consultadas:

http://pt.wikipedia.org/wiki/Universal_asynchronous_receiver/transmitter

http://arduino.cc/en/reference/serial

Configurar o JRE no Ubuntu

Bom hoje fui acessar meu bankline e precisei de instalar o java. Então segue o procedimento para intalar o JRE e configura-los nos browsers Mozilla Firefox e Google Chrome.

 

Baixar o Java no link

http://www.java.com/pt_BR/download/

Hoje em 13/06 a ultima versão era a jre1.7.0_21

Depois utilize os comandos a seguir

$ sudo su

# cd Downloads    

Aqui eu presumi que vc esta na pasta Home/USER e que baixou o arquivo para a pasta default

#  tar -zxf jre-7u21-linux-i586.tar.gz

# mkdir /usr/lib/jvm

# mv jre1.7.0_21 /usr/lib/jvm/

# cd /usr/lib/jvm

#  ln -s jre1.7.0_21 java-7-oracle

#  update-alternatives –install “/usr/bin/java” “java” /usr/lib/jvm/java-7-oracle/bin/java 1

# update-alternatives –install “/usr/bin/ControlPanel” “ControlPanel” /usr/lib/jvm/java-7-oracle/bin/ControlPanel 1

# ln -s /usr/lib/jvm/java-7-oracle/lib/amd64/libnpjp2.so /usr/lib/mozilla/plugins

 

Ou então substitua esses passos por:

 

# apt-get install icedtea-7-plugin

 

Para testar você pode acessar o link:

 

 

Bom essas dicas se originaram de outras pessoas então segue os links originais:

 

http://www.vivaolinux.com.br/artigo/Java-no-Ubuntu-1204-Instalacao-a-moda-antiga/

http://www.ubuntudicas.com.br/blog/2013/03/como-instalar-plugin-java-no-chrome/

 

Até a próxima.

Substituindo o LibreOffice pelo OpenOffice

Olás, estou a um tempo sem escrever e vou dar apenas uma dica breve. Voltei a usar linux como meu principal desktop a 2 meses, e venho tentando engolir o LibreOffice, padrão do Ubuntu 13.04 mas enfim não deu, ele trava em utilização normal, ao usar o scroll do mouse ele deixa a tela preta. Fora que se usar o terminal junto com ele apresenta erros do mesmo jeito.

Enfim segue a dica passo a passo.

Remover o libre office.

$sudo su

# apt-get remove libreoffice*

Baixe o OOO

# wget -c http://tenet.dl.sourceforge.net/project/openofficeorg.mirror/localized/pt-BR/3.4.1/Apache_OpenOffice_incubating_3.4.1_Linux_x86_install-deb_pt-BR.tar.gz

# tar -zxvf Apache_OpenOffice_incubating_3.4.1_Linux_x86_install-deb_pt-BR.tar.gz

# cd pt-br

# cd DEBS

# tar -zxvf Apache_OpenOffice_incubating_3.4.1_Linux_x86_install-deb_pt-BR.tar.gz

E ponto final!

A proposito a dica não e minha o link original esta aqui.

até a proxima

Calculo Numérico com Fortran – Parte 2

Continuando com a série de artigos sobre Fortran, hoje demonstrarei um algoritmo para calculo da soma de Riemman, que é um metodo para calculo da área abaixo da curva sobre um gráfico. Ela é usada para definir a idéia da Integral Definida.

Sugiro que leiam http://www.uff.br/webmat/Calc1_LivroOnLine/Cap21_Calc1.html

Para implementar o método a primeira etapa e definir o intervalo fechado [a,b] que no programa chamamos de limite_inferior e limite_superior, no caso do código abaixoo limite ficou definido enre [-10,10]

 limite_inferior = -10
 limite_superior = 10

Depois precisamos calcular a distância entre a e b, nesse ponto tive o primeiro erro, pois para calcular a distancia não basta somar o valor de a e b, se somarmos -10 e 10 por exemplo a distancia seria 0. Portanto antes de mais nada devemos calcular o modulo.

 !faz o modulo dos limite
 if (limite_inferior.lt.0) then
 modulo_inferior = -1 * limite_inferior
 else
 modulo_inferior = limite_inferior
 endif

 if (limite_superior.lt.0) then
 modulo_superior = -1 * limite_superior
 else
 modulo_superior = limite_superior;
 endif

A precisão desse método vária de acordo com o numero de divisões para cada intervalo x. Sendo que a solução fica mais precisa quanto mais X+n-X tende a 0. Nesse caso n tende a infinito sendo essa a definição da integral definida. Embaixo segue a implementação dessa idéia, quanto maior for n, mais precisa é a solução.

! numero de interavlos entre o limite inferior e o superior
 n=100
 precisao = (modulo_inferior+modulo_superior)/n

Depois definimos x0 como sendo o limite_inferior e x1 o resultado da soma de x0 com a precisão. A partir dai iniciamos um loop, onde o critério de parada é x1 ser igual ou por questões de arredondamento maior que o limite superior.
Dentro do loop, calculamos y_esquerdo e y_direito o valor de ambos e multiplicado pelo valor da distancia entre x0 e x1 (precisão) ao final do loop temos valores para soma_esquerda e soma_direita que indicam o intervalo em que a solução esta contida.

 DO

 !soma esquerda
 if (x0+precisao.lt.limite_superior) then
 f_esquerdo = f(x0)
 soma_esquerda = soma_esquerda + (f_esquerdo*precisao)
 endif

 !soma direita
 if (x1+precisao.lt.limite_superior) then
 f_direito = f(x1)
 soma_direita = soma_direita + (f_direito*precisao)
 endif

 print *,soma_direita,",",soma_esquerda

 x0 = x1
 x1 = x1 + precisao

 ! Se o x1 alcançou o limite superior pare
 if (x1.GE.limite_superior) then
 exit
 endif

 END DO

Definimos a lei que determina a função no trecho de código abaixo:

 FUNCTION F(X)
 REAL*4, INTENT (IN) :: X
 REAL*4 Y/0/
 !definimos a funçao que desejamos avaliar.
 Y = x**4-10*x**3+130*x
 F=Y
 RETURN
 END FUNCTION F

Segue abaixo o código completo:

PROGRAM RIEMMAN

REAL*4 soma_direita/0/
 REAL*4 soma_esquerda/0/
 REAL*4 n/0/
 REAL*4 precisao/0/
 REAL*4 limite_inferior/0/
 REAL*4 limite_superior/0/
 REAL*4 f_direito/0/
 REAL*4 f_esquerdo/0/
 REAL*4 modulo_inferior/0/
 REAL*4 modulo_superior/0/
 REAL*4 x0/0/
 REAL*4 x1/0/

 PRINT *,"Entre um Byte e Outro - Aprendendo Fortran e Calculo Numerico"
 PRINT *,"Anthony M Collucci - Algoritmo para Calculo da soma de Riemman"
 PRINT *,"=============================================================="

 limite_inferior = -10
 limite_superior = 10

 !faz o modulo dos limite
 if (limite_inferior.lt.0) then
 modulo_inferior = -1 * limite_inferior
 else
 modulo_inferior = limite_inferior
 endif

 if (limite_superior.lt.0) then
 modulo_superior = -1 * limite_superior
 else
 modulo_superior = limite_superior;
 endif

 ! Calcula a distancia entre o limite superior e limite inferior e divide pelo numero de intervalos
! numero de interavlos entre o limite inferior e o superior
 n=100
 precisao = (modulo_inferior+modulo_superior)/n
 ! define o x inicial e o x final
 x0 = limite_inferior
 x1 = limite_inferior + precisao

 print *,"soma_direita",",","soma_esquerda"
 DO

 !soma esquerda
 if (x0+precisao.lt.limite_superior) then
 f_esquerdo = f(x0)
 soma_esquerda = soma_esquerda + (f_esquerdo*precisao)
 endif

 !soma direita
 if (x1+precisao.lt.limite_superior) then
 f_direito = f(x1)
 soma_direita = soma_direita + (f_direito*precisao)
 endif

 print *,soma_direita,",",soma_esquerda

 x0 = x1
 x1 = x1 + precisao

 ! Se o x1 alcançou o limite superior pare
 if (x1.GE.limite_superior) then
 exit
 endif

 END DO
 !Debug
 print *,"O valor da área esta entre",soma_esquerda,"e",soma_direita

 STOP

 CONTAINS

 FUNCTION F(X)
 REAL*4, INTENT (IN) :: X
 REAL*4 Y/0/
 !definimos a funçao que desejamos avaliar.
 Y = x**4-10*x**3+130*x
 F=Y
 RETURN
 END FUNCTION F

END PROGRAM RIEMMAN

Vamos avaliar o programa, primeiro acessamos o cmd, e digitamos gnuplot na console digitamos plot x**4-10*x**3+130*x e será exibido o gráfico abaixo:

Sempre gosto de dar uma olhada no gráfico antes de começar, agora imagine que no intervalo de -10 a 10 exibido acima dividimos ele em 100 partes e traçamos gráficos de barra para y(x0) e y(x1) e somamos as áreas desses intervalos. Se fizessemos isso manualmente teríamos um resultado semelhante à saída abaixo:

Se fosse necessário mais precisão bastaria aumentar n, veja abaixo o valor para n=10000

Perceba que o meu erro já e muito baixo, a diferença entre a estimativa para cima e estimativa por baixo, e de apenas 375 milésimos, no meu caso decidi parar por aqui, se você executar o programa verá que ele se torna mais lento quanto maior for N pois o numero de cálculos cresce exorbitantemente.

Cálculo Numérico com Fortran – Parte 1

Depois de um longo jejum de escritos no meu blog, resolvi começar uma nova empreitada, a intenção é aprender Fortran aplicado ao cálculo numérico.

Para os estudos de caso, seguirei a tradução do livro Numerical Methods and FORTRAN Programming (Wiley 64). Porem o livro foi escrito em Fortran IV então fiz um upgrade no código para a versão 90, e como sempre não me limitarei a copiar o código e posso terminar fazendo alguma implementação própria.

Para quem não sabe o que é Cálculo Numérico http://www.alunos.eel.usp.br/numerico/notasDeAula/intro.pdf

Para quem não sabe o que é Fortran http://pt.wikipedia.org/wiki/Fortran

Aqui segue um tutorial para instalação do gfortran e gnuplot http://www.fsc.ufsc.br/~esalcedo/FisComp/Notas/InstalarNowindows/Fortran/f90windows.html

Estou estudando o livro na medida que escrevo por isso, os primeiros algoritmos podem ser bem toscos, pois não domino a linguagem (AINDA) :p

O primeiro estudo de caso proposto por Wiley é o calculo das raízes de um polinômio de 4º grau pelo método da bisseção.

O metodo da bissecção consiste em procurar intervalos valores para x0 e x1, que tornem verdadeiras a afirmativa abaixo F(x0) * F(x1)<=0 , e reduzir esse intervalo cada vez mais até que o valor de F(x) seja o mais próximo ou igual a 0

Para entender melhor usaremos a função y=x^4-9x^3-2x^2+120x-130

Vejamos o gráfico dessa função:

No intervalo de -10 a 10 temos 4 raízes* visualmente podemos distinguir que a primeira esta entre -4 e -3 a segunda entre 1 e 2 a terceira entre 3 e 4 e a quarta entre 7 e 8. A bissecção consiste em pegar esses intervalos e reduzi-los, tomamos como exemplo o intervalo entre -4 e -3, pegamos então o ponto médio entre eles que chamamos de x,  calculamos então o valor de F(x), existem 3 possibilidades, ou F(x) = 0 caso que x é uma raiz, ou F(x)>0 caso em que o a raiz esta entre x e -3, ou F(x) < 0 caso que a raiz esta entre -4 e x.

* Raízes de uma função são valores de X que tornam F(x) = 0

O fluxograma abaixo, demonstra a bissecção dessa função:

Implementando em Fortran:

program teste

REAL*4 XL/0/
 REAL*4 XR/0/
 REAL*4 YR/0/
 REAL*4 YL/0/
 REAL*4 XS/0/
 REAL*4 X/0/
 REAL*4 Y/0/

 WRITE (*,*) "Estudo de Caso 1: Determinacao de raizes por bisseccao"
 PRINT *,"Entre um Byte e Outro - Aprendendo Fortran e Calculo Numerico"
 PRINT *,"Baseado na Traducao do livro Numerical Methods and Fortran Programming (Wiley, 1964)"
 PRINT *,"Adaptação do codigo para Fortran 90 por Anthony Collucci"
 PRINT *,"Esse algoritmo supoe que todas as raizes da funcao estão no intervalo entre -10 e 10"
 Print *," e que entre cada raiz a um intervalo nao inferior a 1"

 !Declarando o Intervalo de pesquisa o XL é o limite inferior.
 XL = - 10
 XR = XL + 1

 PRINT *," Xl ",","," Xr "
 DO
 ! Calcula o valor da função para XL E XR
 Yl = F(XL)
 YR = F(XR)

 PRINT *,XL,",",XR

 ! Caso As raizes estejam entre XL e XR, o produto de YR, e YL sera negativo pois o gráfico da função
 ! cruza o eixo X.

 IF (YR*YL.LT.0) THEN
 !SALVA O VALOR DE XR
 XS = XR

 DO

 !Define o ponto x entre XR e XL
 X = (XR+XL)/2
 Y = F (X)

 IF (YL*Y.EQ.0) THEN
 !Se o produto e 0 então a raiz e x, pois senao haveriamos encontrado ela no if anterior ao loop
 PRINT *,"RAIZ E", X
 EXIT
 ELSEIF (YL*Y.LT.0) THEN
 !Se for menor que 0 significa que a raiz esta entre x e xl
 XR = X
 YR = Y
 ELSEIF (YL*Y.GT.0) THEN
 !Se for maior que 0 significa que esta entre x e xr
 XL = X
 YL = Y
 ENDIF

 ! Se a precisao desejada foi alcancada entao paramos
 IF (XR-XL.LT.0.000005) THEN
 PRINT *,"RAIZ ESTA ENTRE",XL, ",", XR
 !Restaura o valor de XR
 XR = XS
 EXIT
 ENDIF
 END DO
 ENDIF

 ! Aqui definimos que procuraremos uma raiz até o XR = 10.
 IF (XR.GT.10) EXIT

 ! Incrementamos o valor de XR e XL.
 XL = XR
 XR = XL+1

 END DO

 STOP

 CONTAINS

 FUNCTION F(X)
 ! Função que criamos para calcular o valor da função matematica proposta.
 REAL*4, INTENT (IN) :: X
 REAL*4 Y/0/
 Y = X**4 - 9*X**3 - 2*X**2 +120*X - 130
 F=Y
 RETURN
 END FUNCTION F

 end program teste

Veja como fica a saída do programa:

 

 

Links Uteis (Contendo as referencias para a sintaxe):

http://www.fsc.ufsc.br/~esalcedo/FisComp/Notas/InstalarNowindows/Fortran/f90windows.html
http://nf.nci.org.au/training/FortranAdvanced/slides/slides.015.html
http://www.cs.mtu.edu/~shene/COURSES/cs201/NOTES/F90-Basics.pdf
http://www.inf.ufes.br/~thomas/fortran/tutorials/helder/fortran.pdf
http://www.dsc.ufcg.edu.br/~icc/Periodo-2011.2/matadic/Programacao%20em%20Linguagem%20FORTRAN.htm#P050
http://www.ews.uiuc.edu/~mrgates2/docs/fortran.html

Palestra Infotech 2012 – Introdução a Robotica

Participei no ultimo dia 17/05 da Infotech, um evento recheado de palestras que divulguei neste mesmo blog há um tempo atrás evento este que superou minhas expectativas em organização e qualidade das palestras.

Chegando no evento sou surpreendido com um grande alvoroço na entrada da faculdade, era a banda  Flying Reggae animando os estudantes. Cheguei na recepção e informando que era palestrante fui levado ao sexto andar, lá mais surpresas, ex-professores participando do evento como staff, professores como Marcelo Patrocínio, um dos melhores que ja tive, saca tudo de Sistema Operacional o cara!

Depois de um lanchinho testei novamente o Braço Mecânico que levei para demonstração fiz sua calibração e como não tinha muito mais o que fazer fui ver a primeira palestra do Chales Fortes e do Rogerio Ohashi, sobre Threads, confesso que fiquei assustado com o nível  e pensei se a minha não seria básica demais.

Continuando no mesmo auditório assisti a palestra Sobre Lambda Expressions Com Charles Fortes e Marcus Coelho. Tive de sair no final dessa palestra para ajeitar as coisas para a minha.

O Metallica que embalou a galera antes do inicio da palestra serviu para dissipar qualquer nervosismo que eu tivesse. E como sempre saiu tudo diferente do que eu havia pensado mas achei que foi muito produtivo, os ouvintes participaram com suas dúvidas e senti que todo mundo estava bem interessado.

O Ponto alto creio foi o video do BigDog da Boston Dynamics, o Robô cachorro mais impressionate que eu já vi e compartilho abaixo

Realmente impressionante não? Essa mesma empresa possui vários outros robôs incríveis! Vocês podem verificar no canal da empresa no youtube http://www.youtube.com/BostonDynamics.

A galera se interessou também pelo microcontrolador Arduíno que utilizamos na demonstração.

Veja abaixo algumas fotos da palestra:

Minha Pessoa

Demostração do Conceito de Ponte H
A Ponte H Mais criativa que eu já vi
Braço Mecânico
Repassando a Palestra com o Professor Marcelo Patrocinio
Repassando a Palestra com o Professor Marcelo Patrocinio
Braço Mecânico no Telão
Braço Mecânico no Telão
Publico prestando atenção aos slides
Publico prestando atenção aos slides

Compartilho aqui os slides que utilizei nessa apresentação com vocês http://amcollucci.com.br/InfoTech_-_Introdu%C3%A7%C3%A3o%20a%20rob%C3%B3tica.pdf

 

 

Info Tech – Inforium – 2012

Esta para ocorrer a InfoTech na Inforium nos dias 15,16 e 17 de maio, esse autor que vos fala, estará apresentando uma palestra sobre introdução à Robótica no evento, e gostaria de contar com a presença dos leitores desse blog (nossa agora não vai caber tanta gente)

O evento contará com diversos profissionais, principalmente da área de Dev, e terão palestras, sobre RIA, Android, Project 2010, Windows 2008 e muito mais.

O Evento é um esforço da comunidade .NetRaptors e 100loop,com o apoio da Inforium.

Clique no cartaz para realizar sua inscrição no evento.

Pretendo apresentar um braço mecânico e um pequeno follow-line gotta gotta go!!!

 

See you later!!

 

Anthony Collucci

Aprenda a programar o Arduino – Parte 3

Estamos chegando à terceira Parte desse tutorial, hoje começaremos a trabalhar com o arduino ligado a algum hardware e advinha … vamos piscar leds….

Antes de ligarmos qualquer coisa no Arduíno é interessante sabermos um pouco sobre suas características elétricas, aqui vai o datasheet do Arduino Mega 1280 para outros modelos  basta procurar no http://arduino.cc.

Então sabemos que o máximo de corrente que o arduino pode suportar em cada pino é de cerca de 40mA.  Os datasheets que encontrei informam que para uma voltagem de 5v os leds de 5mm  trabalham em média com 40mA.

Não necessariamente a porta do seu arduíno irá queimar se você ligar por exemplo 2 leds em uma mesma porta mas isso não e recomendavel a não ser que você queira correr riscos.

O Led e um componente polarizado portanto não deve ser ligado invertido pois pode queimar. Veja a figura abaixo extraída da wikipedia ensinando a polarizar o Led.

LED
Anodo e Catodo do LED

Portanto o Anodo, com a “perna maior” tem de ir numa porta de IO e o Catodo, deve ir numa porta de GND. (Veremos que isso não é obrigatório mais adiante…).

A montagem é bem simples e você pode conferir na foto abaixo

Arduino Blink
Arduino Blink

O Catodo, deve ser ligado ao pino GND e o Anodo ao Pino 13

Então lets coding!!!!

void setup()
{
pinMode(13, OUTPUT);
digitalWrite(13, HIGH);
}

void loop()
{
}

Acabamos de ligar o led.

O comando pinMode recebe um valor inteiro, que deve ser igual ao numero da porta (estão impressos no circuito do arduino), e uma flag que informa se ele e de saída (Output), ou entrada (Input), no Arduino Mega 1280

Portas PWM e Digital
Portas PWM e Digital

as portas PWM* e Digital utilizam o comando digitalWrite que tambem recebe dois parametros o primeiro e um numero inteiro que é o numero da porta e o segundo e se ela esta alta ou baixa (0 ou 1).

Esse programa tambem pode ser reescrito da seguinte forma:

void setup()
{
pinMode(13, OUTPUT);
digitalWrite(13, 1);
}

void loop()
{
}

Podemos passar a informação da porta por uma variavel:

int pino = 13;
void setup() {
pinMode(pino, OUTPUT);
digitalWrite(pino, HIGH);
}

void loop()
{
}

E claro sempre podemos otimizar o código eliminando o sinal e colocando como uma constante alterando a linha:

int pino = 13;

Para:

const unsigned int pino = 13;

Agora vamos brincar criando um objeto chamado led.

class led  {
private:
int pino;
int estado;
public:
void desliga_led();
void liga_led();
void set_pino(int);
};

void led::set_pino(int i) {
pino = i;
pinMode(pino, OUTPUT);
}

void led::desliga_led(){
estado=0;
digitalWrite(pino,estado);
}
void led::liga_led(){
estado=1;
digitalWrite(pino,estado);
}

void setup() {
led l1;
l1.set_pino(13);
l1.liga_led();
}

void loop(){ }

Aos não iniciados em programação orientada a objetos eu sugiro uma pausa pro café tirar os sapatos, relaxar e ler o seguinte link:

http://www.dca.fee.unicamp.br/cursos/POOCPP/node3.html

Vamos começar a analisar o código:

  class led  {
private:
int pino;
int estado;
public:
void desliga_led();
void liga_led();
void set_pino(int);
};

O trecho destacado em cima, define como a classe vai ser. Quais são os seus metodos e variaveis. Nele vemos duas distinçoes claras private: e public: , tudo que estiver dentro de private, só pode ser alterado ou manipulado por algo que esteja dentro da classe. Tudo que esta dentro de public pode ser acessado externamente.

No nosso exemplo declaramos as variáveis pino e estado como variáveis privadas, ou seja só podem ser acessadas por métodos que estiverem dentro da classe.

Já na divisão public declaramos os metodos desliga_led() liga_led() e set_pino() mas não programamos essas ffunçoes veja que até o momento não haviamos programado de fato essas funções.

void led::set_pino(int i) {
pino = i;
pinMode(pino, OUTPUT);
}

No trecho acima vimos a função set_pino, o leitor poderá perceber, que estamos configurando o pino i como saída, esse i vai ser passado outra parte do código quando chamarmos a função.As outras funções seguem um padrão semelhante.

O que fizemos na verdade é criar um método para cada tarefa. O que a príncipio parece muito difícil e de pouca utilidade visto que o mesmo código somente aumentou de tamanho e não de utilidade, mas veremos adiante o quanto isso pode ser útil. Mas atente que ao utilizar esse tipo de programação seu código ocupara mais espaço em físico.

Criando nossa própria biblioteca para um LED

P*** o cara vai ensinar a criar uma biblioteca, e ainda nem explicou direito como funciona um if!? No Arduíno a programação e voltada para interação com o ambiente. Simplesmente com seus comandos básicos isso se torna muito dificil, já existem diversas bibliotecas criadas para o Arduíno, elas extedem as funções dele para  trabalhar com cartões SD, Motores, Blue Tooth, Sim Cards.. ou seja uma infinidade de coisas. Porém muita gente ao dar #include não sabe nem o que esta fazendo, na parte 4 deste tutorial eu pretendo explicar o funcionamento de um cartão de memória e criarmos algumas aplicações interessantes com ele, portando e interessante que o leitor entenda como funciona uma biblioteca de funçoes, até mesmo para localizar seus métodos sem conhecer ela a fundo ou ter de recorrer a alguma documentação.

Então let’s go.

Eu utilizei o Notepad++ mas você pode usar o que quiser, notepad, wordpad, geany, devc++, eclipse c,vi… Ou qualquer outro editor.

Primeiro devemos criar um arquivo de header que no nosso caso vai se chamar amcled.h esse arquivo deve conter o codigo abaixo

#ifndef amcled_h
#define amcled_h

#include “Arduino.h”

class led
{
private:
int pino;
int estado;
public:
void desliga_led();
void liga_led();
void set_pino(int);
void blk(int);
};
#endif

Depois devemos criar um arquivo chamado amcled.cpp

#include “Arduino.h”
#include “amcled.h”

void led::set_pino(int i)
{
pino = i;
pinMode(pino, OUTPUT);
}

void led::desliga_led(){
estado=0;
digitalWrite(pino,estado);
}
void led::liga_led(){
estado=1;
digitalWrite(pino,estado);
}
void led::blk(int time){
liga_led();
delay(time);
desliga_led();
delay(time);
}

Você precisa agora criar um arquivo que vai destacar os comandos que você criou ao digita-los (colocar eles em laranja na IDE do arduino). esse arquivo deve se chamar keywords.txt

desliga_led KEYWORD1
liga_led    KEYWORD2
set_pino    KEYWORD3
blk            KEYWORD4

Agora você deve criar uma pasta chamada amcled dentro da pasta libraries do Arduino conforme abaixo, e colar dentro dela todos os arquivos que criamos:

Biblioteca de Led
Biblioteca de Led

Depois disso só precisamos abrie e fechar a IDE do arduíno e já poderemos usar a nossa biblioteca.

Biblioteca amcled pronta para o uso
Biblioteca amcled pronta para o uso

 

Agora vamos reescrever o último programa que fizemos utilizando a nossa biblioteca:

#include <amcled.h>
void setup() {
led l1;
l1.set_pino(13);
l1.liga_led();
}

void loop(){ }

Ainda pode parecer que o código ficou maior que o primeiro mas vamos prosseguir para o exemplo do led Blink do site do Aduino disponivel em:

 /*
* Created 1 June 2005
* copyleft 2005 DojoDave <http://www.0j0.org>
* http://arduino.berlios.de
*
* based on an orginal by H. Barragan for the Wiring i/o board
*/

int ledPin = 13;

void setup()
{
pinMode(ledPin, OUTPUT);
}

void loop()
{
digitalWrite(ledPin, HIGH);
delay(1000);
digitalWrite(ledPin, LOW);
delay(1000);
}

O programa acima faz com que o led pisque a cada 1s, pois ele alterna o estado do pino 13 utilizando digitalWrite. Veja eles reescrito com a nossa lib.

/*
* Criado em 18 de Fevereiro de 2012
* copyleft 2012 – Copie e distribua =]
* http://amcollucci.com.br
*
* based on an orginal by H. Barragan for the Wiring i/o board
*/
#include <amcled.h>

led l1;
void setup()
{
l1.set_pino(13);
}

void loop()
{
l1.liga_led();
delay(1000);
l1.desliga_led();
delay(1000);
}

 

Nada muito diferente não é?

Então veja o seguinte codigo: =]

#include <amcled.h>

led l1;
void setup(){
l1.set_pino(13);
}
void loop(){
l1.blk(1000);
}

 

Bom acho que consegui apresentar com sucesso o Led Blink com delay, da maneira mais completa que pude. Durante os proximos tutoriais pretendo avançar ainda mais em alguns itens que toquei durante essa parte.

 

Então até a próxima

*Obs.:Os pinos PWM possuem ainda outras características.

 

Aprenda a programar o Arduino – Parte I

Esse será o primeiro post de uma série onde pretendo ensinar a programar o Arduino. Esse tutorial leva em conta que você ja tenha instalado e configurado a ide do Arduino na sua máquina e que você já saiba ao menos o qué é o Arduino, algum conhecimento prévio de programação e bem vindo!

Primeiro programa no Arduino

Vamos fazer agora um programa que não serve literalmente para nada!  Simplesmente vamos ver o que é obrigatório para o código poder roda veja abaixo:

/*                               Codigo Exemplo Numero 1*****************************************************************
Aprenda a programar o Arduino – Primeiros PassosAutor: Anthony Collucci
Data: 04/02/2012
******************************************************************/
void setup(){
  /* O setup é uma estrutura obrigatória, ele é utilizado para definirmos a
função (i/o) dos pinos do Arduino, serve tambem para inicializarmos
algumas bibliotecas.   */
}
 
void loop(){
  /* O loop tambem e uma estrutura obrigatória, ele executa o codigo
entre {} em ciclos infinitos e repetitivos.  */
}

No exemplo acima utilizamos as duas estruturas básicas Setup() e Loop() que são duas funções como veremos mais adiante. O texto entre “/* */” é simplesmente um comentário ele não afeta em nada a execução do programa, é interessante que o comentário exista para facilitar a leitura e manutenção do código, mas deve -se evitar seu uso em excesso para não diminuir a legibilidade do código com muitas quebras. Isso aí e uma coisa que você vai adquirindo com o tempo!!!

Quando você compilar deve receber um resultado como esse:

Binary sketch size: 674 bytes (of a 126976 byte maximum)

Esse resultado indica qual o tamanho do arquivo e que ele foi compilado com sucesso.

Repare que se você utilizar o seguinte codigo:

void setup(){
}
void loop(){
}

O tamanho do arquivo gerado será o mesmo indicando que os comentários são ignorados após a compilação. Agora atente para o codigo abaixo digite-o e compile:

Void setup(){
}
Void loop(){
}
 

O seguinte erro será exibido:

sketch_feb04a:-1: error: ‘Void’ does not name a type
sketch_feb04a:0: error: ‘Void’ does not name a type
sketch_feb04a:1: error: ‘Void’ does not name a type
sketch_feb04a:5: error: ‘Void’ does not name a type

Isso indica que o “Void” não e um tipo válido para uma váriavel ou função, isso ocorre porque a linguagem usada no arduino e baseada no c/c++ que são linguagens case sensitive.

Começando a brincar com variáveis e comunicação serial

Em todo tutorial de Arduíno que encontram o primeiro exemplo é o do Led Blink, porém acho uma abordagem totalmente inútil, pois ela realmente não ensina nada… Vou começar por outro caminho. Vamos iniciar a comunicação serial e escrever o conteudo de uma váriavel na no console.

Digite esse codigo em sua IDE:

/*
Codigo Exemplo Numero 2

*****************************************************************
Aprenda a programar o Arduino – Primeiros Passos

Autor: Anthony Collucci
Data: 04/02/2012

*****************************************************************
*/
void setup(){
//Inicia a comunicação serial a 9600 bauds
Serial.begin(9600);

}

void loop(){
// Envia a string “Aprendendo a programar no arduino” para a console
Serial.print(“Aprendendo a programar no arduino”);
}

Agora acesse a serial monitor conforme a figura abaixo:

Arduino Serial Monitor
Abrindo o Serial Monitor- Opening the Serial Monitor

O resultado como se segue e uma sucessão de impressões da string “Aprendendo a programar no arduino”. Vimos que iniciamos a comunicação serial através do comando serial.begin(9600) que colocamos dentro do setup(){} . O  valor de 9600 pode variar dependendo da sua aplicação veja mais sobre velocidade da porta serial nesse post:

http://www.tech-faq.com/difference-between-bit-rate-and-baud-rate.html

O comando Serial.print(“string aqui”) que faz com que a informação seja impressa no serial monitor. Adiante veremos outros exemplos do uso do Serial.print, mas por ora quero que reparem que todo comando que não constroí um bloco (não tem “chaves” como o setup e o loop) ou então que não e uma diretiva de pré-processador (#include, #define que veremos adiante tambem)  termina com ponto e vírgula, isso indica o fim do comando.

Digite agora o código abaixo, e veremos um exemplo de uso de váriavel:

/*
Codigo Exemplo Numero 3

*****************************************************************
Aprenda a programar o Arduino – Primeiros Passos

Autor: Anthony Collucci
Data: 04/02/2012

*****************************************************************
*/

/* Podemos declarar uma variavel por linha */
int a;
int b;

/* Ou podemos declarar diversas variaveis por linha */
int c,d;

void setup(){
//Inicia a comunicação serial a 9600 bauds
Serial.begin(9600);
a = 2;
b = 3;
}

void loop(){
// Observe o \n ele e um escape de new line, ou seja muda a linha
Serial.print (“Aprendendo a programar no Arduino \n”);
/* Veja como e facil fazer operações com o arduino, as variaveis
c e d receberao os valores da soma e multiplicação de a e b.*/
c=a+b;
d=a*b;
/* depois de efetuado o calculo imprimimos o valor na console */
Serial.print (“O valor da soma de a e b é: “);
Serial.print (c);
Serial.print (“\n”);
Serial.print (“O valor da multiplicação de a e b é: “);
Serial.print (d);
Serial.print (“\n”);
delay (1000);
}

Agora começamos a complicar um pouquinho mais o nosso código =]. Mas o que fizemos e muito simples criamos 4 variaveis a,b,c,d que são do tipo int ou seja podem receber números inteiros. Depois dentro do setup iniciamos a comunicação serial e atribuimos valores para as variaveis a e b. Dentro do loop, nós realizamos a operação de soma de “a” e “b” e colocamos o resultado na variável “c” depois realizamos a operação de multiplicação da váriavel “a” e “b” e colocamos na variavel “d”, por ultimo usamos o Serial.print e imprimimos o resultado na console. O comando delay (1000) faz com que haja um espera de um segundo entre uma repetição e outra.

Boas práticas…

Vamos agora dar uma olhada em alguns trechos do código e torna-los mais “profissional”. Nesse post só vou tratar da diminuição do tamanho do programa realizando o tratamento de variáveis e tornando assim o codigo mais limpo rápido e menor.

No exemplo 3 a IDE nos retorna a seguinte mensagem:

Binary sketch size: 4326 bytes (of a 126976 byte maximum)

Agora vamos analisar alguns trechos do código e realizar alterações.

As seguintes linhas:

/* Podemos declarar uma variavel por linha */
int a;
int b;

/* Ou podemos declarar diversas variaveis por linha */
int c,d;

serão alteradas para

/* Declaração de constantes */

const unsigned int a = 2;
const unsigned int b = 3;

/* Declaração de variáveis. */

int c,d;

e as seguintes linhas serão deletadas:

a = 2;
b = 3;

Por quê realizamos essas alterações? Simples, você deve ter notado que os valores de “a” e “b” nesse código são constantes ou seja não se alteram durante a execução do programa, então não deixamos um espaço de memória alocada para uma variável do tipo int, simplesmente declaramos diretamente seu valor. O comando “const” declara ela como constante. E como no exemplo o sinal dos operadores não influencia ja que são ambos positivos, nos suprimimos ele com o “unsigned”.

Quando voce compilar vair obter o seguinte resultado:

Binary sketch size: 4274 bytes (of a 126976 byte maximum)

Economizamos 52 bytes  vamos prosseguir. No exemplo abaixo ja fazemos algumas alterações substanciais no código:

/*
Codigo Exemplo Numero 3.1

*****************************************************************
Aprenda a programar o Arduino – Primeiros Passos

Autor: Anthony Collucci
Data: 04/02/2012

*****************************************************************
*/

/* declaramos as constantes */
const unsigned int a = 2;
const unsigned int b = 3;

/*declarmos a variavel resultado*/
unsigned int res;

void setup(){
//Inicia a comunicação serial a 9600 bauds
Serial.begin(9600);

}

void loop(){
// Observe o \n ele e um escape de new line, ou seja muda a linha
Serial.print (“Aprendendo a programar no Arduino \n”);
/* Veja como e facil fazer operações com o arduino, as variaveis
c e d receberao os valores da soma e multiplicação de a e b.*/

//imprimimos primeiro o valor da soma
res=a+b;
Serial.print (“O valor da soma de a e b é: “);
Serial.print (res);
Serial.print (“\n”);
//depois o valor da multiplicação
res=a*b;
Serial.print (“O valor da multiplicação de a e b é: “);
Serial.print (res);
Serial.print (“\n”);
delay (1000);
}

Reduzir o numero de váriaveis não reduziu o código, mas aplicar o “unsigned” foi efetivo. A vantagem de diminuir as váriaveis e que seu codigo usa menos memória ram. Agora o resultado foi esse:

Binary sketch size: 4172 bytes (of a 126976 byte maximum)

Acabamos de economizar 154 bytes.

Por ultimo reduzindo o escopo das variaveis conseguimos reduzir ainda mais o tamanho do código:

Retiramos as linhas abaixo que estavam acima do setup(){}

/* declaramos as constantes */
const unsigned int a = 2;
const unsigned int b = 3;

/*declarmos a variavel resultado*/
unsigned int res;

E recolocamos dentro do loop:

void loop(){
/* declaramos as constantes */
const unsigned int a = 2;
const unsigned int b = 3;

/*declarmos a variavel resultado*/
unsigned int res;

O novo resultado foi:

Binary sketch size: 4140 bytes (of a 126976 byte maximum)

Ou seja conseguimos 182 bytes de redução no código. Essa técnica é bem criticada por muitos programadores, já houve um caso que quase fui crucificado aqui no blog, e o assunto foi tão polêmico que preferi retirar a matéria. Mas ela é uma técnica muito válida quando temos um projeto complexo a ser feito no Arduino, normalmente em projetos complexos temos de incluir várias bibliotecas, que por si só ja impactam o tamanho do programa, não precisamos então agravar isso criando programas ruins!

Bom em breve postarei a continuação desse post. Espero que ele tenha sido útil!

Att,
Anthony Collucci

Manifesto Pirata

Na verdade antes de tudo gostaria de dizer que não sou ou não era a favor da pirataria, pois sempre pensava nos empregos dos artistas e tudo isso. Mas devido a SOPA ACTA PIPA e , com o perdão da palavra, a puta que pariu da sigla que vier agora. Resolvi divulgar o manifesto e trabalho do The Pirate Bay. Ficarei do lado da pirataria até que sjea apresentada uma lei decente. Para lesgilar tanto a internet como os direitos autorais.

Vejam abaixo um e-mail que a Dream works enviou para o The Pirate Bay.

Para quem possa interessar:

Esta carta está sendo escrita para você em nome de nossos
cliente, DreamWorks SKG (doravante denominada “DreamWorks”).
DreamWorks é a proprietária exclusiva de todos os direitos autorais,
marcas registradas e outros direitos de propriedade intelectual
e para o filme “Shrek 2” Ninguém é
autorizado a copiar, reproduzir, distribuir ou
de outra forma utilizar o filme “Shrek 2”, sem
a expressa autorização por escrito da DreamWorks.

Chegou ao nosso conhecimento que o site web
localizado em “http://www.thepiratebay.org” para a qual
você é o prestador do serviço, está reproduzindo,
distribuindo e / ou ofertando para venda o filme “Shrek 2”
. Em anexo estão fotocópias de
páginas representando o site acima mencionado.

DreamWorks tem a convicção de que o uso do
material da forma reclamada não está
autorizada pela DreamWorks, seu representante ou pela lei.
DreamWorks diligentemente impõe seus direitos
ao “Shrek 2” no cinema e em todas as formas de mídia.
O nosso cliente toma legalmente a sua responsabilidade para
a proteção do “2 Shrek” filme muito
a sério.

Como você pode estar ciente, Provedores de Serviço Internet podem
ser responsabilizados se não responderem a reclamações de
infracção nos termos das exigências do
Digital Millennium Copyright Act (DMCA). em
acordo com a DMCA, solicitamos sua ajuda
na remoção de violações ao filme “Shrek 2”
a partir deste site e quaisquer outros sites
para o qual você agir como um provedor de acesso.
Declaramos, sob pena de perjúrio, de que nós
estamos autorizados a agir em nome da DreamWorks e
que as informações nessa carta são verdadeiras.
Entre em contato comigo imediatamente para discutir o assunto
ainda mais.

Nada contido nesta carta constitui um
expressa ou implícita renúncia de quaisquer direitos, recursos ou
defesas da DreamWorks, que são expressamente
reservados.

, Atenciosamente

Dennis L. Wilson
Keats McFarland & Wilson LLP

Abaixo segue a resposta do Pirate Bay:

Como você pode ou não pode estar ciente, a Suécia não é um estado dos Estados Unidos
da América. A Suécia é um país do norte da Europa.
A não ser que entendeu isto agora, a lei dos EUA não se aplica aqui.
Para sua informação, nenhuma lei sueca está a ser violada.Tenha certeza de que qualquer outro contacto com a gente, independentemente do meio,
irá resultar em
a) um processo sendo arquivado por assédio
b) uma denúncia formal apresentada através de seu advogado, para
enviar frívolas ameaças de processo judicial.É de opinião nossa e de nossos advogados que você são ……. imbecis, e
que você deveria por favor sodomizar-se com bastões retráteis.Observe também que o seu e-mail e carta será publicada na íntegra na
http://www.thepiratebay.org.Vá se foder.Educado como de costume,
anakata
Se quiserem rir mais um pouco podem ir aqui: http://thepiratebay.org/legal
 Em momentos como esse (S.O.P.A e P.I.P.A) eu gostaria que o Irã enviasse uma bomba direto na  WhiteHouse… Bom saindo do meu momento devaneio, abaixo vai um post publicado no ThePirateBay que é praticamente um manifesto. Não vou traduzir pois qualquer tradução peca por eliminar a essencia…. E por favor reproduzam o texto, pirateiem copiem, etc…

Over a century ago Thomas Edison got the patent for a device which would “do for the eye what the phonograph does for the ear”. He called it the Kinetoscope. He was not only amongst the first to record video, he was also the first person to own the copyright to a motion picture.

Because of Edisons patents for the motion pictures it was close to financially impossible to create motion pictures in the North american east coast. The movie studios therefor relocated to California, and founded what we today call Hollywood. The reason was mostly because there was no patent.There was also no copyright to speak of, so the studios could copy old stories and make movies out of them – like Fantasia, one of Disneys biggest hits ever.

So, the whole basis of this industry, that today is screaming about losing control over immaterial rights, is that they circumvented immaterial rights. They copied (or put in their terminology: “stole”) other peoples creative works, without paying for it. They did it in order to make a huge profit. Today, they’re all successful and most of the studios are on the Fortune 500 list of the richest companies in the world. Congratulations – it’s all based on being able to re-use other peoples creative works. And today they hold the rights to what other people create. If you want to get something released, you have to abide to their rules. The ones they created after circumventing other peoples rules.

The reason they are always complainting about “pirates” today is simple. We’ve done what they did. We circumvented then rules they created and created our own. We crushed their monopoly by giving people something more efficient. We allow people to have direct communication between eachother, circumventing the profitable middle man, that in some cases take over 107% of the profits (yes, you pay to work for them). It’s all based on the fact that we’re competition. We’ve proven that their existance in their current form is no longer needed. We’re just better than they are.

And the funny part is that our rules are very similar to the founding ideas of the USA. We fight for freedom of speech. We see all people as equal. We believe that the public, not the elite, should rule the nation. We believe that laws should be created to serve the public, not the rich corporations.

The Pirate Bay is truly an international community. The team is spread all over the globe – but we’ve stayed out of the USA. We have Swedish roots and a swedish friend said this: The word SOPA means “trash” in Swedish. The word PIPA means “a pipe” in Swedish. This is of course not a coincidence. They want to make the internet inte a one way pipe, with them at the top, shoving trash through the pipe down to the rest of us obedient consumers. The public opinion on this matter is clear. Ask anyone on the street and you’ll learn that noone wants to be fed with trash. Why the US government want the american people to be fed with trash is beyond our imagination but we hope that you will stop them, before we all drown.

SOPA can’t do anything to stop TPB. Worst case we’ll change top level domain from our current .org to one of the hundreds of other names that we already also use. In countries where TPB is blocked, China and Saudi Arabia springs to mind, they block hundreds of our domain names. And did it work? Not really. To fix the “problem of piracy” one should go to the source of the problem. The entertainment industry say they’re creating “culture” but what they really do is stuff like selling overpriced plushy dolls and making 11 year old girls become anorexic. Either from working in the factories that creates the dolls for basically no salary or by watching movies and tv shows that make them think that they’re fat.

In the great Sid Meiers computer game Civilization you can build Wonders of the world. One of the most powerful ones is Hollywood. With that you control all culture and media in the world. Rupert Murdoch was happy with MySpace and had no problems with their own piracy until it failed. Now he’s complainting that Google is the biggest source of piracy in the world – because he’s jealous. He wants to retain his mind control over people and clearly you’d get a more honest view of things on Wikipedia and Google than on Fox News.

Some facts (years, dates) are probably wrong in this press release. The reason is that we can’t access this information when Wikipedia is blacked out. Because of pressure from our failing competitors. We’re sorry for that. THE PIRATE BAY, (K)2012

Fato e que estamos vivendo num conflito de interesses e nesse momento todos tem de escolher um lado. A minha posição e contra a industria cinematográfica, e televisiva, não somente a globo aqui no Brasil, mas essa industria como um todo.