2 Anos do Blog

      Dois anos atrás lancei esse blog, eu estava procurando um emprego na web e precisava formar um portfolio, alem de claro tem um lugar para testar minhas habilidade em php. Essa onda durou muito pouco, nesse processo de remodelagem da minha carreira passei a incorporar ao Entre um Byte e Outro, cada vez mais informações paralelas, como os tutoriais de Arduino, informações sobre astronomia, ou papo furado mesmo.

     No final das contas o que me deixa mais contente e que mesmo sendo um blog tão pessoal, ele vem ganhando visitantes constantemente, o que me leva a crer que há publico para minhas idéias (perigoso isso pessoal, vocês não deviam me dar essa esperança . muhahhaha). Em 2011 o site passou por uma nova virada e passou a incorporar temas da área de Engenharia Mecânica, curso que iniciei em jan/2011. E novamente houve um crescimento de visitações.

        Esse Post e para agradecer as visitas, pois sem elas com certeza eu não teria animo para manter esse blog. E prometer que ainda tem muito mais, como não sou de comemorar muito meu aniversário, somente posso dizer uma coisa, abram um Brahma, e um brinde e que as mulheres não morram viúvas… \o/

Até logo!

Feira de Profissões Anhanguera – BH

Pelo segundo ano consecutivo tive o prazer junto com Ademir, Romulo e Emerson, de representar os alunos do curso de engenharia Mecânica na Feira de Profissões da anhanguera Belo Horizonte.

Exibimos os vídeos que filmamos durante a nossa participação na Winter Challenge 2012, em Jaguariuna SP, e também o Robô seguidor de linha que utilizamos. Além disso exibimos também o motor do foguete que iremos lançar no dia 20 de outubro, além da base de lançamento e sistema de abastecimento. Nosso publico foram os alunos de ensino médio da capital mineira e esperamos ter estimulados novos futuros engenheiros! 🙂 Seguem abaixo as fotos que tiramos!

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