Arquivo da categoria: Arduino

Aqui, são discutidos assuntos relacionados ao Arduíno, um microcontrolador que usa a idéia do Open Hardware. Mais em www.arduino.cc.

Como começar com Arduíno

Muitas vezes sou bolinado com a mesma pergunta, “queria comprar um Arduíno qual você me indica?”, ou então, “Qual o melhor Arduíno para um iniciante?”, outra muito boa também, ” O Arduíno é bom?”. Nesse post vou tentar esclarecer ao máximo para quem quer embarcar nas aventuras da computação física, robótica, DIY e afins.

Existem diversos tipos de Arduínos, com diversas configurações, se sua pergunta for qual o melhor Arduíno eu diria, basta ir na home, e procurar qual tem mais recursos. Mas na realidade o buraco é um pouco mais embaixo, antes mesmo de comprar um, você deveria se perguntar para quê eu preciso, ou o que eu vou fazer com o meu Arduíno. Muita gente compra kits para aprender a programar como o da figura abaixo.

 

Kit Para Arduíno

Nada contra, mas vejamos, temos um motor o que raios se faz com um motor, talvez um ventilador ou um barquinho, tsc… Um sensor ultrassônico, e um relé, já da pra fazer uma luz que acenda automaticamente… Enfim, o que eu gostaria de dizer a maioria dos kits que já vi, não tem uma finalidade. OK, dá pra aprendera a programar mas enfim, você não irá ficar entretido muito tempo com isso. Então lá vai a minha primeira dica:

Dica 1 – Defina um projeto, um objetivo.

Com um objetivo definido você irá conseguir escolher melhor a placa que você precisa, além disso vai poder comprar componentes relevantes para o seu projeto e aprender do mesmo jeito que se comprasse um kit. Agora vamos supor que o seu projeto seja a automação residencial de sua casa, e o de outra pessoa seja montar um VANT, com certeza eu não deveria indicar a mesma placa concorda?

A segunda dica que eu dou, é depois de definido o objetivo, faça um esboço de tudo que será feito antes de comprar qualquer coisa.

Dica 2 – Rascunhe e pesquise e detalhe.

Agora vem a dica que evita que você gaste dinheiro a toa, e define o tamanho do projeto, veja bem, você enfermeiro, leu que o Arduíno é uma plataforma de prototipagem simples e fácil, e agora quer fazer a automação de sua casa. EXCELENTE, essa é a ideia do Arduíno, agora chegou a etapa então de você visualizar o tamanho do seu projeto, por exemplo quantas lâmpadas você quer controlar, tem o portão da garagem também? Ótimo, como ele é acionado, via corrente alternada ou contínua, qual a tensão e a potência dele. As lampadas vão ser acionadas por proximidade, por toque, por voz por reconhecimento de imagem?

Um amigo meu outro dia me disse, preciso controlar 3 motores de passo com o Arduíno o que me recomenda? Eu disse nada, primeiro preciso saber, qual a tensão dos motores, corrente, modelo. Nessa etapa é legal baixar os datasheets de todos os componentes também e le-los

Dica 3 – Procure ajuda nos fóruns

Bom agora que você detalhou e pesquisou, provavelmente já sabe que precisa de relés para acionar uma lampada que sua corrente alternada usando o Arduíno, mas antes de ir na loja comprar, ou no eBay, procure conselhos com alguém mais experiente, veja um tipo de pergunta legal:

Estou pensando em utilizar o Arduíno para automatizar minha casa, pensei em utilizar o NANO, ou o UNO para ele caber na caixa de distribuição, e também em utilizar um shield de relés, o que vocês acham?

Prepare-se agora para uma chuva de opiniões, contra a favor, algumas respostas inúteis mas em 90% dos casos você receberá informações relevantes, por exemplo na pergunta acima, alguém poderia te questionar se o NANO ou o UNO, seriam capazes de controlar todas as lampadas pois possuem poucas portas, outra pessoa poderia te perguntar quantas lampadas para te recomendar um shield que tivesse um numero de reles suficiente, ou então lhe falar que você teria de desenvolver uma placa externa.

Dica 4 – Comprando por amostragem

Alguns amigos meus possuem o museu do Arduíno em casa, compram não dá certo, compram outra coisa e não dá certo, e amigo, se você for casado, um dia a Dona Onça vai reclamar (experiência própria). Então a dica agora é se você for automatizar 20 lampadas, compre material para 2, faça os testes, provavelmente você nessa etapa ( considerando que é um iniciante), vai ter esquecido detalhes como terminais, e acabamentos, vai suar um pouquinho com a solda, vai apanhar com o código, então e melhor comprar menos e ver se tudo vai funcionar do jeito que você deseja e então comprar o restante.

Dica 5 – Termine o que começou

Não tem nada mais gratificante que concluir um projeto, mas é muito difícil também, você encontra barreiras a cada passo, mas não desanime se deu errado conserte, pense o seguinte, o dia que a automação da sua casa der problema, ou no dia que seu braço robótico der pau, você não terá assistência técnica para reparar pra você. E depois que o projeto é concluído torna-se muito mais fácil executar outro.

Bom talvez não seja a resposta que você tenha procurado no meu blog, mas espero que isso lhe ajude. Comprar um Microcontrolador, ou outra coisa qualquer para começar um Hobbie, e como ir ao médico, tem de ser examinado, não há um diagnostico padrão, tipo tome duas aspirinas que resolve, tudo é relativo. e=mc²

Até a próxima.

 

 

 

Da série “O que não fazer no seu projeto de Drone”

Bom queria ter boas noticias para colocar no Blog, mas hoje foi um fracasso, logo nos primeiros testes queimei dois motores e acredito que um dos ESCs. Provavelmente o motor que veio no helicoptero não aguentou a pressão.

Para quem deseja empreender esse projeto, aconselho, evite ao máximo fios. Desenvolva uma placa de circuito impresso para seu projeto utilize os menores terminais que conseguir.

Bom, agora é comprar novos motores para queima-los   testa-los. Quanto aos esc bora testar pra ver se estão funcionando…

Antes…

Hewlett-Packard

Depois…

O que restou foi a bagunça…

Hewlett-Packard

O ESC  torrado…

Hewlett-Packard Hewlett-PackardMas…

Continua!!!

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

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

Acelerômetro ADXL345 e Arduino Mega 1280

Boa Noite,

00:23 hrs, e consegui finalmente compreender e programar o Arduino para interfacear com o Acelerometro ADXL345, inicialmente. Esse será um breve tutorial de como fazer isso, já que isso não é hora de gente ficar acordada.

O que é um acelerômetro: (Tecmundo)
Segundo a primeira lei de Newton: ”Todo corpo permanece em repouso até que alguma força externa aja sobre ele.” Já a segunda lei define a força aplicada como o produto da massa do corpo pela sua aceleração. Logo, medindo a aceleração aplicada sobre um corpo (e seu peso), é possível determinar a força aplicada sobre ele.

Acelerômetro do iPhone (imagem de divulgação)

Um acelerômetro nada mais é que um instrumento capaz de medir a aceleração sobre objetos. Ao invés de posicionar diversos dinamômetros (instrumento para medir a força) em lugares diferentes do objeto, um único acelerômetro é capaz de calcular qualquer força exercida sobre ele.

Leia mais em: http://www.tecmundo.com.br/2652-o-que-e-um-acelerometro-.htm#ixzz1gBn98TBJ

O ADXL 345

Datasheet: http://www.sparkfun.com/datasheets/Sensors/Accelerometer/ADXL345.pdf

O ADXL345 é bem adequado para medidas de aceleração estática da gravidade em aplicações tilt-sensing, bem como aceleração dinâmica resultante do movimento ou choque. Sua alta resolução (4 mG/ LSB) permite a medição de mudanças de inclinação inferiores a 1,0 °.

Várias funções especiais de detecção são fornecidas. A detecção de atividade e inatividade detecta a presença ou ausência de movimento e se a aceleração em qualquer eixo excede um nível definido pelo usuário. Detecção de queda livre detecta se o dispositivo está caindo. Estas funções podem ser mapeados para um dos dois pinos de saída de interrupção.

Bom vamos ao trabalho

Para interfacear o Adxl 345 tive de soldar 4 fios nele para liga no Arduino. Utilizei o Padrão i2c para comunicação então o hardware e bem simples siga a tabela que não vai haver problemas.

Pino Arduino    Pino Adxl

3v3                         vcc e cs

gnd                          gnd

20                            sda

21                             scl

Se você usar outra versão do arduino os pinos scl e sda vão variar, mas dai e so dar uma olhada no site do Arduino…

Depois da pinagem vale a pena dar uma olhada e créditos nos dois sites a seguir:

http://www.sparkfun.com/tutorials/240

https://www.loveelectronics.co.uk/Tutorials/12/adxl345-accelerometer-arduino-tutorial

No segundo site eu consegui baixar a biblioteca que trabalha com o acelerômetro. Porém ela foi escrita para o compilador 0022 do Arduino, e estamos na versão 0023, portanto depois de baixar a biblioteca, você deve abrir o arquivo .c dela e proceder com as seguintes modificações:

– substituir #include<Wprogram.h> por #include<Arduino.h>

– substituir wire.send por wire.write

– substituir wire.receive por wire.read

E depois você coloca a biblioteca na pasta librarie do seu Arduino.

Pronto agora basta executar o exemplo que vem na própria biblioteca e ele vai funcionar. O exemplo pode ser conferido tambem abaixo:

/*
ADXL345_Example.pde - Example sketch for integration with an ADXL345 triple axis accelerometer.
Copyright (C) 2011 Love Electronics (loveelectronics.co.uk)

This program is free software: you can redistribute it and/or modify
it under the terms of the version 3 GNU General Public License as
published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

// Include the Wire library so we can start using I2C.
#include <Wire.h>
// Include the Love Electronics ADXL345 library so we can use the accelerometer.
#include <ADXL345.h>

// Declare a global instance of the accelerometer.
ADXL345 accel;

// Set up a pin we are going to use to indicate our status using an LED.
int statusPin = 2; // I'm using digital pin 2.

void setup()
{
  // Begin by setting up the Serial Port so we can output our results.
  Serial.begin(9600);
  // Start the I2C Wire library so we can use I2C to talk to the accelerometer.
  Wire.begin();

  // Ready an LED to indicate our status.
  pinMode(statusPin, OUTPUT);

  // Create an instance of the accelerometer on the default address (0x1D)
  accel = ADXL345();

  // Check that the accelerometer is infact connected.
  if(accel.EnsureConnected())
  {
    Serial.println("Connected to ADXL345.");
    digitalWrite(statusPin, HIGH); // If we are connected, light our status LED.
  }
  else
  {
    Serial.println("Could not connect to ADXL345.");
    digitalWrite(statusPin, LOW); // If we are not connected, turn our LED off.
  }

  // Set the range of the accelerometer to a maximum of 2G.
  accel.SetRange(2, true);
  // Tell the accelerometer to start taking measurements.
  accel.EnableMeasurements();
}

void loop()
{
  if(accel.IsConnected) // If we are connected to the accelerometer.
  {
    // Read the raw data from the accelerometer.
    AccelerometerRaw raw = accel.ReadRawAxis();
    //This data can be accessed like so:
    int xAxisRawData = raw.XAxis;

    // Read the *scaled* data from the accelerometer (this does it's own read from the accelerometer
    // so you don't have to ReadRawAxis before you use this method).
    // This useful method gives you the value in G thanks to the Love Electronics library.
    AccelerometerScaled scaled = accel.ReadScaledAxis();
    // This data can be accessed like so:
    float xAxisGs = scaled.XAxis;

    // We output our received data.
    Output(raw, scaled);
  }
}

// Output the data down the serial port.
void Output(AccelerometerRaw raw, AccelerometerScaled scaled)
{
   // Tell us about the raw values coming from the accelerometer.
   Serial.print("Raw:\t");
   Serial.print(raw.XAxis);
   Serial.print("   ");
   Serial.print(raw.YAxis);
   Serial.print("   ");
   Serial.print(raw.ZAxis);

   // Tell us about the this data, but scale it into useful units (G).
   Serial.print("   \tScaled:\t");
   Serial.print(scaled.XAxis);
   Serial.print("G   ");
   Serial.print(scaled.YAxis);
   Serial.print("G   ");
   Serial.print(scaled.ZAxis);
   Serial.println("G");
}

Palestra sobre Lógica da Programação no Colégio Magnum

Dia 15 de dezembro estive junto com o Professor Paulo Roberto, palestrando no Colégio Magnum Sobre lógica da programação para alunos do ensino Médio.

Inicialmente o Prof Paulo, discursou sobre a lógica matemática, desde a sua Origem com o filósofo Aristoteles até a demonstração dos Teoremas de De Morgan. O mais interessante foi o jogo que ele desenvolveu que utiliza a lógica matemática em cartas. Infelizmente o tempo não foi suficiente para jogarmos uma partida.

Gostei também da historia que ele contou sobre o ~(p^q) ou ” não p e q ” segue a história que ele contou para explicar:

Uma garota vai fazer 15 anos e seus pais pedem pra ela listar os amigos que ela quer ver na festa.

Dai então ela entrega a lista para seus Pais que vão olhando nome por nome.

Seu pai para em um nome e diz , conheço o “P” e toda vez que vi ele em uma festa ele brigou.

Prosseguindo com a leitura seu Pai encontra “Q” e diz que “Q” bebe muito e apronta nas festas tambem.

So que sua mãe ao ver esses nomes diz, olha já fui em festas onde estava P , e em festas onde estava Q e eles não brigaram, o problema e quando os dois estão juntos (p^q)

Então seus pais viram para a menina, e dizem ~(p^q) ou no português ” não p e q”.

A menina muito triste liga pra sua colega e diz: _Papai não quer nem p nem q na minha festa.

Ai vem a pergunta a menina entendeu o que os pais lhe disseram?

Bom de minha parte eu levei o Arduino, para os garotos conhecerem, demonstrei o uso das portas lógicas em circuitos elétricos e fiz alguns codigos no arduino para testar a o funcionamento dos operadores lógicos e provar na prática a teoria de lógica.

Falei tambem sobre diferentes utilizações da lógica matemática, por exemplo em sensores eletrônicos, e ainda da utilização da matemática em áreas de Engenharia e Informática.

Fica aqui tambem registrado a ótima impressão que tive dos alunos do Colégio, todos eles muito educados, e atenciosos, e claro com vontade de aprender, a galerinha fica depois do horário normal de aula em determinados dias da semana para estudar lógica e matemática.

 

Servo Motores novamente…

A pouco tempo escrevi sobre como controlar servos na unha, bom agora eu quero e montar uma library, para isso tive de melhorar o código, a intenção era usar millis() para controlar o lapso de tempo entre os pulsos, mas a verdade e que estou apanhando para as funções micros() e millis() do arduino.

Fora isso, eu vou postar um código bem melhorado em relação a última versão!


// define o pino em que o servo esta conectado

const unsigned int pinservo = 9;

// definem o maximo e o minimo em Microsegundos, da largura do pulso
unsigned int maximo = 2400;
unsigned int minimo = 70;

//Armazena o ultimo passo enviado para o servo, evitando que ele receba um comando para permanecer onde esta, evitando assim trepidação
unsigned int ultimopasso = 0;

// intervalo em Milisegundos entre um pulso e outro
unsigned int interval = 15;

//velocidade com que o servo movimenta
unsigned int velocidade = 10;

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

void loop(){

//executa diversos passos e da um delay de 1 segundo entre um e outro.

passo (90);
delay (1000);
passo (45);
delay (1000);
passo (120);
delay (1000);

}

void passo (int _grau){
 unsigned int _passo= minimo + (maximo/180)*_grau;
 if (ultimopasso != _passo){ //impede a repetição do mesmo passo senao fosse assim causaria  trepidação
 if (ultimopasso &lt; _passo){ //se o servo estiver antes da proxima posição ele avança
 for (int i=ultimopasso;i&lt;_passo;i= i + velocidade){
 digitalWrite (pinservo, 1);
 delayMicroseconds(i);
 digitalWrite (pinservo, 0);
 delay(15);
 }
 }else{ //caso contrario ele recua
 for (int i=ultimopasso;i&gt;_passo;i= i - velocidade){
 digitalWrite (pinservo, 1);
 delayMicroseconds(i);
 digitalWrite (pinservo, 0);
 delay(15);
 }
 }
 }

ultimopasso = _passo; //grava o ultimo passo
}

Bom e simples assim! Agora estou seguindo os passos deste tutorial, e desenvolvendo uma library própria.

Até a próxima nerdeza!!