Arquivo da categoria: Engenharia

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

Winter Challenger – Robocore – 2012

Tenho andado sumido desse blog, mas não morri pelo menos eu acho, nesses ultimos meses andei envolvido em muitas coisas que tomaram completamente meu tempo uma delas foi a Winter Challenge 2012, a competição organizada pela Robocore aconteceu na Faculdade de Jaguariuna (FAJ) nos dias 8,9,10 de junho de  2012.

Eu e mais 7 alunos da Anhanguera, Ademir, Emerson, Felipe, Gabriele, Leonardo,Lindonei e Rômulo,  de Belo Horizonte resolvemos participar do evento e fundamos a ART (Anhanguera Robotic Team) e com o slogan “Because Engineering is ART” desenvolvemos um robo seguidor de linha que foi o 11º colocado entre 30 concorrentes no evento.

O projeto original consistia em um jerico, um veiculo articulado, com tração dianteira e uma malha de sensores que fariam o robo virar proporcionalmente à posição do sensor acionado. Esse robo seria comandado por um arduíno e seus motores a combustão interna, seu chassi seria cortado a laser e seria feito de aço inox.

O leitor mais atento irá perceber que a frase passada foi construída no passado e não foi a toa. Parafraseando Jack Sparrow “Complicações surgiram, continuaram e foram superadas”. Terminamos com um chassi rígido de acrílico, servo motores e rodas de aeromodelo.

Durante a competição

   1º dia –


Depois da viagem à Jaguariúna montamos o ambiente de testes, eu ainda nutria a esperança de montar um sistema de auto-calibração pra evitar as dificuldades da calibração individual, chegamos no dia 07 dia do check-in, e inspeção de segurança. Na parte da manhã os sucessivos insucessos só serviram para baixar o ânimo e aumentar a insegurança. No fim descobrimos que a cartolina refletia parte da luminosidade ambiente e atrapalhava os sensores nessa hora nosso espirituoso amigo Romulo, apelidou nosso robô de “Troxão”. Resolvemos ir para a competição ver o que tinha por lá… Nessa hora a Gabi pensava seriamente se me matava ou aleijava…

Montando a "saia"
Montando a “saia”

Posso lhes dizer ganhar não ganhamos mas até nó em pingo d’água nos demos nessa competição, logo ao chegar percebemos que podíamos fazer testes na pista de competição. A empolgação voltou e corremos para trazer as ferramentas e retomar os trabalhos. A foto acima mostra o resultado dos testes do primeiro dia, detectamos que a interferencia externa era muito dificil de ser resolvida via software, então com ajuda de tecnologia avançada , Feltro e Cola Quente, montamos uma “Saia” que escondia os sensores da interferencia luminosa do meio ambiente. Voltamos para o chalé e desfrutamos de um rodizio de carne excelente e depois de uma cerveja nosso espirituoso amigo Rômulo, já estava chamando o garçom de meu amigo e a velhilha do lado de meu amor.

2º dia

Danado de bêbado não tem dono, e o Ademir tem longas histórias a contar do Rômulo, trabalhamos muito nesse dia tentando ajustar o sensor de parada, cada tentativa que passava estávamos certos que na próxima  ia dar certo mas a próxima não chegava… Assim decidimos almoçar e terminamos descobrindo o segredo da parada entre a linha de chegada e a linha de largada, o negocio era cronometrar o tempo médio que o robô demorava para completar toda a volta e assim fazê-lo parar depois desse tempo, assim conseguimos ajustar o robô para percorrer a pista sem maiores incômodos, tantos foram os testes realizados que na hora H ficamos sem bateria…. O robô se arrastou pela pista na hora da competição e cravou 2:19, mais 40s e estávamos fora. Mas nada me tira da memória a felicidade de ver o robô completando a pista, depois de todas as dificuldade do projeto, somando a isso ver que poucos conseguiram sucesso mostra a grandeza da façanha logo no primeiro dia de competição (segundo em Jaguariúna).

3º dia

Dia super agitado, logo de manhã as baterias quase explodiram, apos um período de sobrecarga =]… isso e uma longa historia… No fim das contas corremos em campinas e conseguimos apenas uma bateria de 6v de chumbo acido de quase 1kg. Como torque não era o problema o robô conseguiu andar durante algum tempo e acreditávamos termos resolvido o problema. Dai ocorre o desastre… As engrenagens dos servos não suportam a nova carga e alguns dentes se partem. Nova luta, corremos para o centro de Jaguariúna e encontramos uma loja de aeromodelismo, la compramos 2 novos servos e 4 rodas para aeromodelo. Ao voltamos nova maratona, adaptar os servos para rotação continua, fixarmos ao chassi, balancearmos as rodas e…. percebermos que o sistema dos sensores não estava legal, após aumentarmos a roda, a distancia dos sensores para o chão ficou maior. Mudamos a fixação dos sensores e desenvolvemos um sistema de altura regulável, utilizamos uma borracha de câmara de ar de moto para construir uma saia e protegermos os sensores da luz externa. Nesse dia cravamos 1:34, e com a sensação de dever cumprido fomos assistir a besta da UNIFEI, vencer o Touro da Riobotz

4º dia

Por fim o ultimo dia, hehe, precisávamos de velocidade e não tinhamos como alterar mais motor, sofftware etc… Então pensamos, se alteramos o diâmetro das rodas e mantermos a mesma velocidade angular, nossa velocidade linear vai ser maior. Ou simplesmente se a roda e maior, e a roda gira a mesma quantidade, o carro anda mais rápido. Tentamos aumentar a tensão do servo motor, mas não tivemos sucesso pois o carro ficou tão rápido que qualquer correção que ele fazia, tendia a sair da pista e tornava necessária nova correção. Fizemos nossa volta e cravamos 1’19”. Após isso foi correr para casa, 600km de volta para casa e um dia de serviço logo depois.

 

 

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 4

Estamos aqui mais uma vez para falar sobre o Arduino, o tutorial dessa vez será um pouco mais curto, pois estou trabalhando em meu projeto de iniciação científica, além de precisar estudar física e OpenGL de preferência hoje ainda. Mas nem por isso vamos deixar de tirar proveito deste post ok?

Para quem está acompanhando estas postagens a medida que elas estao sendo lançadas Houveram 2 alterações, houve uma errata postado na Parte 2, e como havia comentado no forum do Arduíno estava estudando a possibilidade de inserir algumas sugestões do Bubulindo.

Então let’s go!

Estrutura de Pastas do Arduíno

Estrutura de pastas do Arduino
Estrutura de pastas do Arduino

Quando acessamos a pasta do Arduino vemos uma estrutura como mostrada na imagem acima, não há muito o que falar sobre a organização, mas destacam-se as pastas que marquei em vermelho.

– examples – Contém os sketchs de exemplos os mesmos que você acessa no menu file->examples

– reference – Contem arqivos html de ajuda, os mesmo que existem no site do Arduino e que voce pode acessar no menu help->reference

e os dois mais importantes

– libraries – contem as bibliotecas do sistema chegamos inclusive a criar uma na Parte 3 desse tutorial voce pode inserir uma librarie usando a diretiva #include ou acessando o menu sketch->import Libray

– hardware – essa pasta contem a implementação da linguagem c/c++ usada no arduíno e é sobre ela que iremos falar hoje.

 

O Header Arduino.h

O Header Arduino.h se encontra  na pasta hardware\arduino\cores\arduino ele e responsavel pela definição dos protótipos de classes e por incluir todo o core do arduino portanto quando incluimos o Arduino.h na library que criamos o que estamos fazendo e importar todo o core do Arduino e assim podemos utilizar os comandos implementados nessa linguagem. Nesse arquivo você pode ver os seguintes includes:

#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <avr/pgmspace.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include “binary.h”
#include “pins_arduino.h”

#include “WCharacter.h”
#include “WString.h”
#include “HardwareSerial.h”

Bom então já sabemos quais as bibliotecas que estão disponiveis no core, ou seja sem necessitarem de uma diretiva #include. Na prática o que isso nos fala é o seguinte:

Programa em linguagem C utilizado em um PC.

#include <math.h>

main(){

float a = cos(30);

}

Ja no Arduíno

void setup(){}

void loop(){
float a = cos(30);
}

Ou seja apenas elimina a necessidade de incluirmos a biblioteca math.h, o mesmo ocorre para todas as outras que mostramos acima.

Outra coisa interessante no Arduino.h são as constantes predefinidas

#define HIGH 0x1
#define LOW  0x0

#define INPUT 0x0
#define OUTPUT 0x1

#define true 0x1
#define false 0x0

#define PI 3.1415926535897932384626433832795
#define HALF_PI 1.5707963267948966192313216916398
#define TWO_PI 6.283185307179586476925286766559
#define DEG_TO_RAD 0.017453292519943295769236907684886
#define RAD_TO_DEG 57.295779513082320876798154814105

Na pratica isso nos diz que:

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

void loop(){}

é igual a:

void setup(){
pinMode(13,OUTPUT);
}
void loop(){}

 

Isso é interessante de saber pois  na maioria das bibliotecas são utilizados conceitos semelhantes a esse.

Outro local para ser observado nesse arquivo são as definições dos prototipos das funções:

void init(void);

void pinMode(uint8_t, uint8_t);
void digitalWrite(uint8_t, uint8_t);
int digitalRead(uint8_t);
int analogRead(uint8_t);
void analogReference(uint8_t mode);
void analogWrite(uint8_t, int);

unsigned long millis(void);
unsigned long micros(void);
void delay(unsigned long);
void delayMicroseconds(unsigned int us);
unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout);

void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val);
uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder);

void attachInterrupt(uint8_t, void (*)(void), int mode);
void detachInterrupt(uint8_t);

void setup(void);
void loop(void);

 

Aqui estão declaradas os prototipos dos comandos que utilizamos, lembrando que os comandos de C/C++ como os do Arduino, são na verdade funções e ou metodos!

Agora vamos parar um pouquinho e analizar o arquivo main.cpp

#include <Arduino.h>

int main(void)
{
init();

#if defined(USBCON)
USB.attach();
#endif

setup();

for (;;) {
loop();
if (serialEventRun) serialEventRun();
}

return 0;
}

Aqui podemos ver que foi inserido o Header do Arduino, depois o programa declara a função main, o void dentro do parentesis informa que essa função nao recebe parametro. Logo nao inicio da main, a função init(), é invocada, o que ela faz? Ela se encontra em Wiring.c você vê o código dela aqui ou então na pasta hardware\arduino\cores\arduino . Ela e um framework para microcontroladores AVR, e ela tem de ser executada antes de setup(), senão algumas funcionalidades deixam de funcionar.

Depois do tratamento da USB é iniciado a função setup(), essa função somente e prototipada em Arduino.h, que vai cria-la é você, no seu sketch, e o mesmo ocorre com a função loop, que se você verificar esta em um laço infinito. O comando if (serialEventRun) serialEventRun(); Entrou no loop para corrigir um problema que fazia com que o hwserial, não fose acionado a cada chamada ao loop como você pode ver no mail-list.

Por isso que na discussão o Bubulindo apontou meu erro, eu desviava a função setup para outra função que quando finalizava retornava ao setup() que ao finalizar passava para o loop infinito. Aproveitando que estamos aqui vamos implementar uma função end() que permita finalizar o programa do arduino, bom a utilidade disso é bem pouca, precisei disso num caso muito especifico mas bastava executar o loop vazio como mostrei na segunda parte desse tutorial. Mas vale a experiência.

Primeiro vamos criar o prototipo da função no Arduino.h. Coloquei o prototipo abaixo do prototipo de Setup() e loop()

void setup(void);
void loop(void);

void end (void);

Depois criamos algumas alterações no arquivo main.cpp

#include <Arduino.h>

unsigned short int continua = 1;
int main(void)
{
init();

#if defined(USBCON)
USB.attach();
#endif

setup();

while (continua > 0){
loop();
if (serialEventRun) serialEventRun();

}

return 0;
}

void end(void){

delay(100);

continua = 0;

}

 

Com essas pequenas alterações implementamos uma função que finaliza o programa, seu uso e super simples veja o codigo abaixo já utilizando essa função.

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

}

void loop(){

Serial.print(“Oi implementamos a função end \n”);

end();

}

 

Pronto se compilou corretamente sua IDE ja possui a função end!

Bom galera hoje vou parando por aqui, minha idéia e continuar na proxima parte falando sobre a biblioteca para cartões de memória, como ela funciona, como montar um “shield” ,não tem nem como dar esse nome, para cartão de memória. Espero sua visita!

att,

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 2

Quando estava montando um braço mecânico na faculdade precisei de usar algumas estruturas que não rodassem em loop, me deparei com a pergunta como faço para executa-las fora do loop do Arduino sendo que ele trata essa função como se fosse uma main() (por ser obrigatória) do C (dummies abaixo eu explico melhor ok 😉 )

No Arduino o programa começa a ser executado pela função Setup(). Depois de concluído ele procura a função loop() e inicia sua execução, o que eu fiz e vou mostrar nesse post e como interromper o fluxo e apontar uma função que você criou para ser executada. É extremamente simples, pode até parecer boçal… Mas eu passei algumas boas horas para ter a epifania, pois ao imaginar o codigo do arduíno ele parece tratar a setup como se fosse uma função para configurar o mesmo, mas na verdade dentro do proprio loop, você pode setar um pino, dar um atach numa interrupção etc…

****************************************************************************************************************************

Observe que não deixamos de executar o loop como bem observado pelo bubulindo no forum do Arduino, como vocês podem conferir a discussão no link abaixo:

http://arduino.cc/forum/index.php/topic,93283.0.html

* Trechos em negrito inseridos para corrigir erro na publicação original

****************************************************************************************************************************

Então vejamos o seguinte código:

void setup(){

Serial.begin(9600);

naoqueroloop();

}

void loop(){

}

void naoqueroloop(){

Serial.print(“Estou fora do loop”);

}

Se você executou corretamente quando abrir o Serial monitor obterá a seguinte tela.

Saída Serial Monitor Arduíno
Saída Serial Monitor Arduíno

Sem o meu logo é claro… Agora veja como o programa seria executado se não houvessemos criado essa função:

void setup(){

Serial.begin(9600);

}

void loop(){
Serial.print(“Estou dentro do loop \n”);

}

O código acima gera a seguinte saída:

Saida Serial monitor loop()
Saida Serial monitor loop()

Bom já que estamos aqui não vou gastar o post apenas explicando isso. Vamos falar um pouco tambem sobre funções. Funções servem para agrupar comandos que juntos fazem alguma tarefa.

Veja a definição segundo o Site do curso de C da UFSC :  “Uma função é um bloco de código de programa que pode ser usado diversas vezes em sua execução. O uso de funções permite que o programa fique mais legível, mais bem estruturado. Um programa em C consiste, no fundo, de várias funções colocadas juntas. ”

O corpo de uma função e composto pelo tipo de retorno, nome da funçao, parametros, chaves de inicio e fim da função, e comandos..

tipo nome_funcao (parametros) {

comando_1;

comando_2;

}

Funçoes podem ter o tipo void, int, float e qualquer outro que uma váriavel possa receber, nos exemplos anteriores vimos vários exemplos de funçoes do tipo “void” , esse tipo de função não retorna nenhum valor, ou seja apos ser chamada ela cumpre sua função e não devolve nenhum resultado para o programa.

Para esclarecer melhor vejamos uma função do tipo int.

void setup(){

Serial.begin(9600);

}

void loop(){

int numero1=8;
int numero2=10;
int resultado=soma(numero1,numero2);
Serial.print(resultado);
Serial.print(“\n”);
delay(1000);
}

int soma(int a, int b){
int c;
c=a+b;
return c;
}

No programinha acima, temos uma função chamada soma(), essa função e do tipo int, e tem dois parametros, a e b, do tipo inteiro ou em inglês integer. Dentro dessa função foram declaradas 3 variaveis a,b,c duas delas tem seu valor obtido através da passagem de parametros soma(numero1,numero2) nesse momento o valor de a e b passam a ser os mesmos de numero1 e numero2, logo abaixo a variável c recebe o valor da soma de a e b esse valor é retornado atraves do comando return c; Já no loop() a variável resultado recebe o valor de retornado pela função soma().

Até agora tá tranquilo não é?

Então dá uma olhada nesse programa e tentem entender, tem muita coisa que eu não expliquei ainda mas é bom pra dar uma exercitada, e tambem para quem já tem algum conhecimento, o programa a seguir imprimi no serial monitor o triângulo de pascal.

/*
Codigo Exemplo Triangulo de Pascal

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

Autor: Anthony Collucci
Data: 12/02/2012

Esse algoritmo não foi otimizado
*****************************************************************
*/

/* sendo k o numero da coluna e n o numero da linha*/
int k,n;

/*
criaremos uma matriz de 20 por 20 para armazenar os valores
o que nos dará 400 numeros na memoria!!!!
*/

int numero [19][19];

void setup(){

Serial.begin(9600);
zera_variaveis();
pascal();
}

void loop(){
}

void pascal (){

/*inia o calculo pela linha 1 coluna 1*/
k=n=1;
numero [n][k]=1;
Serial.print(numero [n][k]);
Serial.print(“\n”);

for (n=2;n<19;n++){
for (k=1;k<=n;k++){
numero [n][k] = efetua_calculo();
Serial.print(numero [n][k]);
Serial.print(”  “);
delay(100);
}
Serial.print(“\n”);
}

}

int efetua_calculo(){
int resultado;

if (numero[n-1][k]==0){
resultado = numero [n-1][k-1];
return resultado;
}
if (numero[n-1][k-1]==0){
resultado = numero [n-1][k];
return resultado;
}

if (numero[n-1][k-1]!=0 && numero[n-1][k]!=0){
resultado = numero [n-1][k-1] + numero [n-1][k];
return resultado;
}
return 0;
}

void zera_variaveis(){

/* Fui obrigado a criar essa funçao pois ao criar as variaveis
elas vem com um valor aleatorio, lembrando que a matriz começa
no indice 0 mas estamos facilitando as coisas

*/
for (n=1;n<19;n++){
for (k=0;k<19;k++){
numero[n][k]=0;
}
}
}

Aqui você vê a saída deste programa:

Triângulo de Pascal - Arduíno
Triângulo de Pascal - Arduíno

Fico por aqui até a próxima!

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

Como Santos Dumont inventou o avião

Estou trabalhando em uma pesquisa e li um artigo intitulado “Como Santos Dumont inventou o avião” de autoria de Rodrigo Moura Visoni e João Batista Garcia Canalle, que mesmo sendo um trabalho muito remotamente correlato ao meu me despertou muita atenção, o trabalho é uma descrição técnico/histórico de como Santos Dumont, partiu de um aparelho Aerostato que a principio deveria ser mais leve que o ar para o Avião (14-bis e Demoseille).

Santos Dumont era um Balonista residente na França, ele começou a se tornar famoso como aviador, quando concorreu 3 vezes consecutivas  pelo premio Deutsch tendo falhado nas duas primeiras tentativas com sua maquina o Dirigivel nº 5 e na terceira com o dirigivel nº 6 finalmente obteve exito ao realizar a volta na Torre Eiffel em menos de 30 minutos. Mostrando ao mundo a possibilidade de “dirigibilidade” dos artefatos aéreos e dando uma prévia da sua genialidade.

Em 1901 a bordo do numero 6 Santos Dumont dá a volta na Torre Eiffel

Em 1902 ele dá uma nova mostra de sua Genialidade, publica para a revista North American Review um artigo onde explica que na verdade o príncipio por trás do voo do nº 6 não era aerostação. O nº 6 apesar de utilizar Hidrôgenio, somente o usava para manter rigido sua forma de fuso. Obviamente que o empuxo gerado pela baixa densidade do hidrôgenio sustentava boa parte do peso da Aeronave mas ela nunca seria capaz de voar sem as suas hélices que nessa versão empurravam cerca de 2okg do peso da aeronave.

Parando um pouco com  a parte histórica gostaria de comentar que existem 4 forças Aerodinâmicas Básicas: Tração, Sustentação, Arrasto e Peso. Sendo que na verdade Peso e uma força gravitacional.

Utilizando-se de materiais construtivos leves no Dirigivel nº6, Dumont minimizou o peso, ao invés de usar uma estrutura rija, o invetor inflava a estrutura com hidrogênio e preferia utilizar aluminio ao aço.  A Sustentação se dava pela baixa densidade do material atuando em conjunto com a tração gerada pela hélice movida por um motor a combustão, essas características faziam com que enquanto a hélice estivesse em funcionamento nº6 tende-se a sair do chão. E por último o arrasto causado pelo formato de fuso e tamanho do balão, tornavam esse veículo lento.

Em 1904 foram criados mais algumas competições de aviação que incentivaram Santos Dumont a construir em 1905 o menor dirigivel do mundo o Nº 14, que teve duas versões uma com um motor de 14 cv e outra com 16cv que não obtiveram um desempenho satisfatório. Em 1906 Santos Dumont desenvolve um veículo híbrido o 14-bis (ou o 14 de novo). Que era uma máquina “bem feia” na minha opinião, consistia em uma aeronave mesclada com um dirigivel.

Primeira versão do 14-bis

O Legal aqui foi que não foi eu o único a achar a máquina feia e deselegante. Apesar da máquina projetada por Santos Dumont obedecer às regras da competição e ser por definição um avião, o Capitão Ferdinand Ferber membro do Aeroclube da França, disse a Santos Dumont, que a máquina era impura, e que os problemas de aviação deveriam ser resolvidos pela aviação. Santos Dumont aceitou as crítica e desistiu de competir com essa versão do 14-Bis nessa parte tomo a liberdade de citar o artigo original:

7. O “Oiseau de Proie I”

O Oiseau de Proie tinha 4 metros de altura, 10 de comprimento e 12 de envergadura. A hélice ficava atrás, movida por um motor Levavasseur de 24 cavalos. O trem de pouso possuía duas rodas. O piloto ia em pé, em uma cesta situada entre as asas, clara influência da tradição de Dumont como balonista e resquício da configuração original da máquina.

Em 29 de julho, valendo-se de um asno, Santos Dumont içou o Oiseau de Proie por meio de um sistema de cabos até o alto de uma torre de 13 metros de altura (2 metros ficavam enterrados no chão), instalada há alguns dias em sua propriedade em Neuilly. O avião, suspenso por um gancho móvel conectado a um fio de aço inclinado, deslizou sem a hélice 60 metros do topo da torre até outra menor, de apenas 6 metros, fincada no Boulevard de la Seine. O metódico inventor procurava testar com isso os comandos de vôo [11].

Em agosto de 1906 Santos Dumont alterou o trem de pouso com a colocação de uma pequena roda traseira. No dia 21 tirou o avião do hangar e deslocou-se para o campo de provas de Bagatelle, onde experimentou a hélice em marcha. O eixo motor não resistiu e se quebrou. No dia seguinte uma hélice nova forneceu 1.400 rotações por minuto. No dia 23 o aeroplano fez 25 km/h sobre o gramado, sem decolar [12].

Era preciso aumentar a potência. Em 3 de setembro Santos Dumont substituiu o motor de que estava se valendo, de 24 cavalos-vapor, por um de 50, emprestado por Louis Charles Bréguet (1880-1955). Nos dias 4 e 7 desenvolveu velocidades de 35 km/h e percebeu que a decolagem estava iminente. Marcou a prova para o dia 13, em Bagatelle.

8. O “Oiseau de Proie II”

No dia 23 de outubro de 1906 Santos Dumont voltou a Bagatelle para concorrer ao Prêmio Archdeacon. Apresentou-se com o Oiseau de Proie II, uma modificação do modelo original. As asas haviam sido envernizadas para reduzir a porosidade do tecido e aumentar a sustentação. A roda traseira, por atrapalhar a decolagem, foi suprimida [14].

O biplano decolou logo na primeira tentativa, feita às 16h45min: ficou 6 segundos no ar, atingiu 3 metros de altura e voou 60 metros, mais do dobro da distância necessária para a vitória (Fig. 6). O Oiseau de Proie II entrava para a história como o primeiro avião vencedor de um prêmio aeronáutico [15].

A grande sacada de Alberto Santos Dumont, foi “não reconstruir a roda”  fosse a dirigibilidade de aeronaves fosse o emprego da aviação ante aerostação partindo do que já existia Dumont foi realizando alterações, melhorias até chegar ao seu objetivo.

Bom vou parando por aqui pretendo escrever em breve sobre como iniciei minha compreensão sobre foguetes, tomando por base a análise do voo de um avião. Até lá!