Talkie Walkie and made a challenge to build a robot only with one servo, and this was what I came up with.

I used the sound sensor I’ve done a few days ago and a little paper-boat + a servo and a box and this is the result :)

This how the puppet works:

A hole was digger on a card box, and the micro servo is glued to the box as you can see.
One piece of paper is glued to the servo horn, and this will make the puppet talk movement.
Another piece of paper is glued to the box and it will be fixed and hold the puppet.

This is how the puppet is glued to the paper supports.   ;)

Arduino Sound Sensor

Finally I have some time to continue with this investigation and great improvements were achieved with the circuit provided by Ant:

First here are the photos deleted by mistake from flickr:

Headsets microphones

Electrec thingey inside.

The circuit

This is a closeup of the circuit, I´ve added a 10uF capacitor to stabilize the output signal (it´s the green cap on the right).

The problem here is that I can´t imagine myself soldering all this components onto a pcb, I would like to have at least two of these, four would be awesome.

Click the following button to see source code for Arduino and Processing

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

Arduino Code

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

int analogValue;
int val;

void setup()
// start serial port at 9600 bps:


void loop()
// read analog input
analogValue = analogRead(0);

// send values to processing
Serial.println(analogValue, DEC);

// pause for 10 milliseconds:


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

Processing Code

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

// import the Processing serial library
import processing.serial.*;

// declare a font variable
PFont font48;

int linefeed = 10; // Linefeed in ASCII
Serial myPort; // The serial port

// value recieved from the serialport / arduino
int sensorValue;

// mapped value
float sensorValueMap;

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – Setup

void setup() {
myPort = new Serial(this, Serial.list()[0], 9600);

// read bytes into a buffer until you get a linefeed (ASCII 10):

size (800, 600);
background (0);

// you need to have this font in your machine, if not go to
// Tools – Creat Font – and create your own font
font48 = loadFont(“alask_48.vlw”);



// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – Serial Event

void serialEvent(Serial myPort) {
// read the serial buffer:
String myString = myPort.readStringUntil(linefeed);

// if you got any bytes other than the linefeed:
if (myString != null) {

myString = trim(myString);
// split the string at the commas
// and convert the sections into integers:
int sensors[] = int(split(myString, ‘,’));

// print out the values you got:
for (int sensorNum = 0; sensorNum < sensors.length; sensorNum++) {
//print(“Sensor ” + sensorNum + “: ” + sensors[sensorNum] + “\n”);

// sensor
sensorValue = sensors[0];
//sensorValueSmooth = sensors[1];


// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – Draw

void draw() {

// set the black backgrounf

// run the displayText() function

// map the recieved values
sensorValueMap = map(sensorValue, 0, 1024, 0, 800);

// draw a rectangle based on the variable sensorValueMap
rect (0, 100, width, sensorValueMap);

// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – Display Text

void displayText() {

text(“Sensor Value”, 20, 80);
text(sensorValue, 450, 80);


// – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – Save image

void keyPressed(){

G’Remote – Arduino based remote controller

27-August-2009 UPDATE:
My friend Gerhard from Germany asked me to build a walkthrough regarding the G-Remote, with part list, schematics and code. And here it is.  Enjoy  :D


This is my first attempt to make a custom remote controller, and also my first customized Arduino.
After seeing this post made by OddBot I wanted to try to make one myself.

I figured out that if I purchased one remote controller it would be cheaper than buying two of these and paying shipment to Portugal.

So, ripping the guts from a game remote controller I get two joysticks, a couple of buttons, two nice motors and one small lcd.

Each joystick have one button inside, that is cool  :-)

Now I have more control over my bots, specially the ones with two motors.. will post videos later.

no comments on this one :-)


This came up with the need of having the arduino permanently installed on the robots, I´m tired of having to remove the arduino from one bot to the other, and then rewire everything, and then reupload the code everytime I have a new idea, or everytime I want to show the bot to someone.

So I followed the ITP Physical Computing tutorial, and it works like a charm, now I want to try to upload code with the FTDI cable, and If I have success on this I can start making my custom Arduino boards. :D

The link below might be of interest:

Burning the bootloader without an external AVR-Writer


Update: 18.03.09

And here´s the trick to upload code without having to remove the chip to a normal Arduino board, and then put it back on the breadboard, I´m using an FTDI cable, Black and Red connect to GND and +V, he RX from the FTDI cable goes to the AVR’s TX (pin3) and the FTDI’s TX goes to AVR’s RX (pin2).

“I hold down the reset button, press the upload button, count to three, then release the reset button. Then the IDE seems to upload the smoothest.” Full credits to Rudolph for sharing the trick.

Another mighty trick is using a 0.01 uf cap between the RTS (green wire) and reset pin, it will make an auto reset before uploading!!! I´ve made my day!! :D    Thank you Rory  ;)


Testing the circuit with the L293D :-)

Control your motors with L293D

After long research and trial and error,  I´ve came up to a new walkthrough regarding this nice chip, the L293D.
Each project is one project and each one has its own unique power configurations, so you must be aware of the best battery choice and how to distribute voltage through your robot.

I strongly advice you to read the following articles:

Picking Batteries for your Robot
Once you’ve decided on batteries, how do you regulate the voltage


L293D gives you the possibility to control two motors in both directions – datasheet


The L293D Circuit:

Basic Implementation:

This is the most basic implementation of the chip.

As you can see, a 5V Voltage Regulator is between the battery and pins 1, 9, 16.

Pin 8 gets power before the VReg, if your motor needs for example 6V you should put 6V directly in this pin, all the other pins should not get more than 5V.

This will work with no problem at all, but if you want to do the right implementation take a look at the next example:

This is the correct Implementation (with the capacitors), and note that pin 8 is feeded by unregulated voltage. This means that if your motors need more than 5V, you should power this pin with that amount of voltage, and the rest of the circuit with 5V.

The capacitors stabilize the current.

The same circuit on a breadboard:

Soldered on a pcb and ready to go:

This is the back of the circuit, click for high resolution photo.

// Use this code to test your motor with the Arduino board:

// if you need PWM, just use the PWM outputs on the Arduino
// and instead of digitalWrite, you should use the analogWrite command

// —————————————————————————  Motors
int motor_left[] = {2, 3};
int motor_right[] = {7, 8};

// ————————————————————————— Setup
void setup() {

// Setup motors
int i;
for(i = 0; i < 2; i++){
pinMode(motor_left[i], OUTPUT);
pinMode(motor_right[i], OUTPUT);


// ————————————————————————— Loop
void loop() {






// ————————————————————————— Drive

void motor_stop(){
digitalWrite(motor_left[0], LOW);
digitalWrite(motor_left[1], LOW);

digitalWrite(motor_right[0], LOW);
digitalWrite(motor_right[1], LOW);

void drive_forward(){
digitalWrite(motor_left[0], HIGH);
digitalWrite(motor_left[1], LOW);

digitalWrite(motor_right[0], HIGH);
digitalWrite(motor_right[1], LOW);

void drive_backward(){
digitalWrite(motor_left[0], LOW);
digitalWrite(motor_left[1], HIGH);

digitalWrite(motor_right[0], LOW);
digitalWrite(motor_right[1], HIGH);

void turn_left(){
digitalWrite(motor_left[0], LOW);
digitalWrite(motor_left[1], HIGH);

digitalWrite(motor_right[0], HIGH);
digitalWrite(motor_right[1], LOW);

void turn_right(){
digitalWrite(motor_left[0], HIGH);
digitalWrite(motor_left[1], LOW);

digitalWrite(motor_right[0], LOW);
digitalWrite(motor_right[1], HIGH);

update 26/4/09

My 1st instructable  :)

Control your motors with L293D and ArduinoMore DIY How To Projects

O Teu Primeiro Robot com Picaxe

Esta tradução foi feita com o consentimento do seu autor.
O artigo original encontra-se aqui.
Todas e quaisquer questões relativamente ao seu conteúdo deverão ser discutidas no forum LMR (se possivel em inglês) .

Todas e quaisquer questões relativas à tradução para português por favor comuniquem ao tradutor (eu) .

Este projecto não requere conhecimento de electrónica, e não está no âmbito deste projecto aprofundar muito neste sentido, apenas vai fazer com que dês o primeiro passo na construção de um robot muito rapidamente.  É baseado num sistema chamado Picaxe que apesar de ser muito simples é também bastante poderoso. Se quizeres experimentar outra plataforma igualmente simples e robusta existe o Arduino.
Tens aqui um projecto simples que usa um Arduino e uma breadboard para construir um simples perseguidor de luz.

Tempo de construção: 2 horas

URL com mais informação

Custos: $85 / 60€

Bem-vindos(as). Antes de começarmos, aqui estão umas coisas que deves ler:

  1. Para teu próprio interesse, lê isto antes de continuares
  2. Se procuras um projecto ainda mais simples e menos dispendioso, este pode-te interessar:
  3. Se nunca construiste um robot antes, este video pode-te inspirar, verás que é muito fácil e que não precisas nenhum material em especial para o fazer:
  4. Para saberes onde poderás ir depois, aqui tens uma 2ª parte

OK – vamos começar  ;-)

Como começar um robot fixe por aproximadamente 85$

Isto é fixe porque:

  • A electrónica que se usa são “peças reais” (não se trata de peças inventadas que para funcionar precisam de muitas horas de modificação, e também não se trata de um simples kit de peças que é só montar e já está).
  • É fácil e simples, terás um robot feito dentro de aproximadamente uma hora!
  • Podes evoluir a partir daqui, mesmo com as mesmas peças, se não te importares de desmontar o teu robot.
  • É barato.
  • É um projecto a sério, e é divertido! É também o projecto mais divertido de construção de um Robot.. fim da história!  :)

Estas links tratam-se apenas de sítios que uso para descobrir componentes na web. Podes usar qualquer loja que gostes é claro. Convém dares uma olhada nesta página para veres “onde podes adquirir Picaxe”

Os preços são sempre aproximados. Tenta ao máximo obter todos os componentes da mesma loja, e se possível de uma loja localizada no teu país para obteres os melhores preços e a maior rapidez na entrega.


1 PICAXE-28X1 Starter Pack
A placa de 28 pins neste pacote é como o jogo o Mario Bros, divertido e cheio de extras e coisas por descobrir, e faz com que queiras continuar a brincar uma e outra vez. O pacote inclui o cérebro principal, o PICAXE-28X1.

É um pouco dispendioso, mas é a única e a primeira vez que eu te recomendo a comprar, inclui muitas coisas básicas, um Cd-Rom com imensos manuais, cabos, a placa, o Microprocessador, etc.. Na verdade torna-se bastante barato. Pacotes similares costumam custar 10 vezes a mais o seu preço!

Certifica-te que obténs a versão USB, a imagem nas lojas pode não corresponder e mostra um cabo serial quando tu compras um cabo USB. Quando comprares a versão USB, não é necessário que compres o cabo USB pois este já vem incluido na caixa.

Podes comprar aqui

Uma vez que tiveres feito a compra, apenas precisas de comprar um Microcontrolador e uma placa nova para futuros projectos, sai muito mais barato e tornas-te num inventor de robots com todas as ferramentas necessárias.

Para fazeres ligações com mais facilidade aconselho-te a fazeres mais um pequeno investimento e compra female to female jumpers. Aconselho bastante esta compra, apesar de não ser estritamente necessário vais ver que te facilita a vida.


1 L293D Motor Driver – Controlador de 2 motores

O nome diz tudo, falaremos mais sobre este chip :)

Podes comprar aqui


1 PICAXE Servo Upgrade Pack

– Uma maneira simples de obter um servo coberto com todos os componentes necessários para este projecto.

Podes sempre obter um servo standard, os pins macho iguais na imagem e uma resistência de 330 Ohm em vez do chip amarelo fazem o mesmo.

Podes comprar aqui

O que é um Servo?
Um Servo é um componente bastante usado na robótica. Resumindo é como uma pequena caixinha preta com uns fios, e um eixo que gira cerca de 200 graus. Neste eixo podes montar um disco ou um outro qualquer periférico que aconpanhe o servo.

Os 3 fios são para: 2 para alimentação e um para envio de sinal.

O fio do sinal liga-se a algo que controle o servo, neste caso o microcontrolador.

O resultado é que o microcontrolador dá ordem ao servo para onde é que o eixo deva girar, e isto é muito útil; Tu podes programar algo para se mover para uma determinada posição.


1 Sharp GP2D120 IR Sensor – 11.5″ / Analógico
11.5″ou outro raido de alcance serve. Não compres a versão Digital dos sensores Sharp para este tipo de projectos, eles não medem as distâncias da mesma maneira que os analógicos.

Podes comprar aqui

Certifica-te que obténs o conector vermelho/preto/branco. Nem sempre vem incluido e não é um conector standard.

Este sensor não é o meu favorito, normalmente uso sensores de ultrasons, por ex o SRF05 (também se vendem loja-picaxe onde lhes chamam SRF005 e tem uma imagem da traseira do SRF04 na loja! Mas o correcto é o SRF05, eu já lhes disse mas….) Enfim, o SRF05 é muito mais fiável e preciso. Também é mais rápido e custa um pouco mais, é um pouco mais complicado de ser programado e mais complexo de se instalar – por isso não o vou usar aqui, se não tiveres experiência opta pelo Sharp.

Se optares pelo SRF05, está aqui um pequeno tutorial em que ensino a ligá-lo e a programá-lo


2 Motores com redutoras e rodas
Quanto mais alto o rácio, mais forte será o robot, quanto mais baixo mais rápido será o robot. Recomendo um rácio algures entre 120:1 e 210:1 para este tipo de projecto. A razão pela qual o robot é tão lento, é que este tem um rácio elevado. Lentidão é mais simples para inciantes, é mais simples de entender e de acompanhar o que acontece.

Preço total para 2+2: 15 USD
Podes comprar aqui

Também vais precisar:

  • Fita adesiva de dupla face (aquela com a parte fofinha no meio é a melhor)
  • Alguns fios
  • Fita adesiva normal (poderá servir para isolar as ligações)
  • Equipamento de soldar simples (qualquer um simples e barato serve)
  • Uma tesoura, um alicate e um canivete podem sempre ser úteis
  • Uma chave de parafusos

Podes também comprar já agora:

Onde encontrar manuais para os produtos Picaxe

OK! Fizeste a encomenda, já recebeste o material.. e deixa-me adivinhar, querer começar a construir o teu robot  :)   vamos lá começar!


Primeiro monta as rodas nos motores. Monta as tiras de borrachas nas rodas.


Uma maneira fácil e rápida de montar coisas no teu robot (e bastante sólida e duradoura)  é usando fita adesiva (aquela que tem uma parte fofinha no meio) de dupla face.


Coloca as pilhas na caixa, assim terás uma ideia real do peso e do equilibrio do chassis do robot. Põe fita adesiva de dupla face na base da caixa e na base do servo também.



Escolhe o teu próprio design, se achares que o meu “design” é muito simples adicciona coisas como quizeres.

O principal é que tudo esteja bem colado. Pilhas, Servo e Roda. As rodas e o servo devem poder girar livremente, e o robot deve conseguir equilibrar-se nas rodas, balançando ou não.

Remove as pilhas para evitar algum curto circuito durante a montagem!


Agora o cérebro.

Deves ter uma placa de projecto semelhante a esta.

(isto pode ser do teu interesse:

Nota que tem um chip já inserido. Remove-o. Este chip é um Darlington-driver, não vamos precisar dele neste projecto, por isso podes removê-lo.

É fácil remover chips dos sockets, basta inserir com cuidado uma chave de fendas e fazer uma ligeira pressão e retirar o chip com muito cuidado.


Um chip novo normalmente não encaixa logo dentro do socket, terás que dobrar com muito cuidado os pins para o interior em ambos os lados. Pousa o chip lateralmente numa mesa e dobra os pins ligeiramente, repete o mesmo processo do outro lado. (os pins encaixam no socket)

Certifica-te de que todos os pins ficam encaixados.

Se compras-te o upgrade de Servo da loja Picaxe, tens contigo um chip amarelo. Mete-o no mesmo sitio do Darlington.

Nota que sobram dois orifícios do socket onde entra o chip amarelo. Não te preocupes pois é mesmo assim.

Este chip amarelo são 8 * Resistências de 330 Ohm´s num só pacote. Assim, se em vez do chip tiveres uma resistência podes apenas inseri-la na slot com o número “0”, este é o único que vamos usar pois só temos um servo neste projecto.


Insere também o chip maior, o cérebro, o microcontrolador, o Picaxe 28 (nº de versão) na placa de projecto.

É importante ter isto do lado correcto. Repara que há uma pequena marca num dos lados da placa.

O chip vai ser alimentado através da placa através de 2 dos seus pins.

Todos os restantes pins estão ligados à volta da placa, e serão todos programáveis, podes enviar voltagem se quizeres controlar algo ou receber voltagem se quizeres analizar algo.


Agora insere o controlador de motores L293D.

Este chip recebe quatro saidas (outputs) do microcontrolador, e transforma-as em 2. É estranho não é? Mas é assim mesmo acredita… Qualquer saída do microcontrolador tem sempre dois estados “on” ou “off”. Isto limitaria os movimentos do nosso robot, só poderiamos ter o estado de “andar” ou “parado”. Não seria possivel inverter a direcção do motor. Isto não seria muito agradável se o nosso robot fosse em direcção a uma parede.

A placa é feita de maneira inteligente, então os 2 outputs ficam com o seu próprio espaço com a marca (A) e (B) logo a seguir ao chip L293D (vê na figura abaixo).  Falaremos sobre isto mais tarde.


Na parte de trás da placa encontras umas fitas de plástico. Podes removê-las pois não têm qualquer utilidade.


Usa 4 fios e solda-os nos orifícios “A” e “B”.  Podes sempre usar terminais ou qualquer outro tipo de connector.


Se tiveres fita termoretráctil usa-a. Isto dá longevidade e isolamento às tuas ligações.


O fio correspondente 2 “A” vai para um pin do motor, e o fio do 2 “B” vai para outro pin do mesmo motor. Não importa qual é qual, desde que os fios “A” sejam ligados a um motor e os “B” a outro.



Agora vamos às ligações do servo.

Se leste a documentação do Picaxe, viste que recomendam usar duas fontes de alimentação diferentes quando se usam servos ou motores. Resumindo, sim é uma boa prática, mas como este robot é tão simples não é necessário.

Vais precisar de soldar um pin extra ao output “0”, se quizeres usar a ligação normal para o servo. Este pin vem como Picaxe Upgrade Pack (vem uma fileira destes pins), mas só vais precisar apenas de um para cada servo, e estes podem ser adquiridos em qualquer loja electrónica.

Se o cabo do teu servo for (Preto, Vermelho, Branco) ou (Preto, Vermelho, Amarelo), o Preto deve ficar na ponta da placa. O meu é (Castanho, Vermelho, Laranja) e então o castanho fica na ponta.

O truque é normalmente o Vermelho; a referência deste é “V”, “V+”, “+”, “1”.. qualquer umas destas referências é usada.

O fio preto ( ou castanho no meu caso) é “G”, “GND”, “0”, ou “-“. É conhecido como Ground, e é para onde a voltagem se dirige. Lembras-te dos 2 pólos das aulas de física?

A última cor é “o sinal” e pode ser Branco, Amarelo ou Laranja.

O servoo precisa de ambos “+ e -” ou “V e G” e sinal.

Alguns outros dispositivos podem precisar apenas de Ground e Sinal, outros poderão precisar de Ground, Voltagem, Sinal de entrada e Sinal de Saida. Pode ser confuso ao ínicio mas com o tempo habituas-te. Até eu me habituei   :)



Vamos agora colocar a “cabeça”, o sensor Sharp IR.

Se estiveres a usar um sensor de ultrasom tipo o SRF005 vê isto porque a programação é diferente.

Há milhões de maneiras de fazer isto, seguem algumas pistas:

Vermelho precisa de ser ligado ao V1, isto é (nesta configuração) qualquer coisa marcada com “V”, terá que ser ligada aqui.

O Preto vai para o G.

O Branco liga-se ao Input Analógico 1.

O que vês na imagem é o seguinte, cortei o cabo de um servo velho e queimado, e uni o cabo do servo ao cabo do sensor e isto facilita a ligação.

Se usares este método ou outro qualquer para ligar o Sharp IR, deverás ligar também os 3 restantes inputs analógicos ao V. Eu tinham alguns “jumpers” de sobra, e podes que as 3 ligações que sobram estão cortadas. ( O último par,  deixei-o ficar, são apenas dois “Ground”, e não precisamos de unir estes.)

A razão pela qual é importante ligar as entradas analógicas restantes, é porque são “left floating”. Isto significa que se não as ligasses, terias uma leitura dos valores do sensor cheia de “ruido”.


OK! Vamos agora ao que interessa  :)      “Let there be life”

Deverás ter o fio Vermelho vindo das pilhas (+) ligado ao Vermelho na placa. E o Preto (-) ligado ao (G).
A maneira como fazes estas ligações dependerá do teu projecto e dos teus componentes.
Certifica-te sempre que o (+) das pilhas liga ao (V) na placa. E o (-) das pilhas liga ao (G). Isto convém sempre sempre duplamente verificado, assim evitas que os componentes se danifiquem.

Não alimentes a placa com mais do que 6V (nem mesmo pilhas de 9V).

NOTA: estamos apenas a funcionar com uma fonte de alimentação. Mais tarde vais ter que partilhar o Ground, mesmo usando o V1 e o V2. Desta maneira poderás usar uma fonte de alimentação para a placa e outra fonte de alimentação (mais forte) para os motores.

Instala o Picaxe Programming Editor num PC, segue o manual para ligar o Jack / USB / Serial.

Instala as pilhas no teu robot (ainda sem cabeça), insere o jack na placa.. e no programa de edição do Picaxe escreve:

servo 0, 150

pressiona F5, espera que o programa transfira o código para a placa, e podes ver que o servo gira, ou dá um pequeno salto (dependendo da sua posição)

Se algo correr mal aqui, certifica-te que as ligações estão todas bem, volta a ler o manuel, e se mesmo assim não encontrares uma solução escreve nos forums (em inglês).

Se tudo estiver bem, para efectuar outro teste experimenta escrever:

servo 0, 200

e pressiona F5

O servo deverá girar um pouco e parar, para andar em sentido contrário escreve:

servo 0, 150

e pressiona F5

Agora o “pescoço” do teu robot está a olhar em frente.

Cola o Sharp IR no disco do servo, e isto vai ser a “cabeça” do teu robot.


“Olá Mundo, eu sou um robot, e esto pronto a obedecer às tuas ordens e explorar o mundo  :)

Finalizas-te os passos básicos!


O design pode variar, podes ter usado outros componentes, peças, etc.. Mas se fizeste as ligações como descritas anteriormente, aqui estão algumas pistas para te iniciares na programação do robot:

Faz copy-paste deste código para o editor, e pressiona F5:



readadc 1, b1 ‘ lê a voltagem recebida no pin analógico 1, e assigna este valor à variável b1
debug ‘ aqui mostras o valor no na janela do editor. Selecciona “Byte” se estiver em “Word”
goto main


Agora põe a tua mão na frente do robot e vê se a variável b1 é alterada. Vais usar este valor para decidir o que deverá acontecer quando existe algum obstáculo a determinada distância.

Deves também usar um qualquer tipo de suporte para apoiares o chassis do robot, pois as rodas vão começar a andar.

Copia este código para o editor e pressiona F5 com o robot ligado.


high 4

low 5


Uma das rodas deverá começar a rodar numa direcção. Verifica se ambas as rodas andam na mesma direcção e para a frente. Se for o caso, esta deverá ser a instrução de futuro para fazer o teu robot andar para a frente.

Se as rodas andarem para trás tenta desta maneira:


low 4

high 5


Para activares a outra roda escreve:

high 6

low 7

Já falámos anteriormente do servo.

Para um lado é:

servo 0, 75

Para o outro:

servo 1, 225

– ao centra:

servo 1, 150

Aqui está um pequeno programa que vai (ou que deverá, se tudo estiver correcto e se todos os parametros de controle de motores também estiverem correctos) fazer o robot andar, parar em frente das coisas, olhar para cada um dos lados para decidir qual a melhor alternativa, virar para esse lado e continuar a andar em procura de novas aventuras.


Symbol dangerlevel = 70 ‘ a que distância devem estar as coisas antes de reagirmos ?
symbol turn = 300 ‘ o quanto devemos virar
symbol servo_turn = 700 ‘ quanto tempo devemos esperar que o servo vire (dependendo da sua velocidade) antes de medirmos as distâncias

main: ‘ o loop principal
readadc 1, b1 ‘ ler quanta distância está à nossa frente
if b1 < dangerlevel then
gosub nodanger ‘ se nada estiver à frente, continua em frente
gosub whichway ‘ se houver algum obstáculo decidir para que zona se deve ir

end if
goto main ‘ aqui termina o loop, o resto são sub-routinas

nodanger:’ aqui deverá estar a tua combinação para fazer o robot andar em frente, aqui precisas de ajustar os valores consoante a maneira como ligaste os teus motores
high 5 : high 6 : low 4 : low 7

gosub totalhalt ‘ primeiro stop!

‘Olhar para um lado:
gosub lturn ‘ olha para um lado
pause servo_turn ‘ esperar que o servo termine de virar
gosub totalhalt
readadc 1, b1

‘Olhar para o outro lado:
gosub rturn ‘ olhar para o outro lado
pause servo_turn ‘
esperar que o servo termine de virar
gosub totalhalt
readadc 1, b2

‘ Decidir qual é a melhor via a seguir:
if b1<b2 then
gosub body_lturn
gosub body_rturn
end if

high 6 : low 5 : low 7 : high 4 ‘ aqui deverá ser a combinação que vira o robot para um lado
pause turn : gosub totalhalt

high 5 : low 6 : low 4 : high 7 ‘
aqui deverá ser a combinação que vira o robot para o outro lado
pause turn : gosub totalhalt

servo 0, 100 ‘ olha para um lado

servo 0, 200 ‘ olha para o outro lado

low 4 : low 5 : low 6 : low 7 ‘ low nos quatro pins pára o robot!
Servo 0,150 ‘ olha em frente
wait 1 ‘ para tudo por 1 segundo

Com alguma programação e adaptação a este código, podes fazer o robot andar e ao mesmo tempo ir virando a cabeça e tomar decisões, fazer pequenos ajustes à sua rota, virar em direcção a “zonas de interesse” por exemplo portas abertas, e tudo isto ao mesmo tempo enquanto ele se move. É muito engraçado o robot ir olhando para os lados enquanto anda.  ;)

Não te esqueças de ver a 2ª parte deste tutorial.


Podes também adiccional um pequeno buzzer ao example pin 1 e ao ground e escrever:

Sound 1, (100, 5)

– ou então fazer algo de acordo com o programa que vimos anteriormente:

Sound 1, (b1,5)

– assim obtemos sons engraçados consoante a distância dos objectos.

Podes também adiccionar um LED ao pin 2 e ao ground, e escrever:
(notaq que os leds têm uma maneira correcta de serem ligados e podem precisar de uma resistência para não queimar)

High 2

acende o LED

Low 2

apaga LED  ;)


– e que tal um apontador Laser montado num servo extra? Podes fazer com que o robot aponte o laser de um lado para o o outro, ligá-lo, desligá-lo.. podes fazer qualquer coisa que imaginares  :)

Benvindo a um mundo muito divertido que é o de fazer robots, existe uma grande diversidade de sensores, actuadores, motores à espera de serem ligados e de darem vida a robots  :)

Não te esqueças de partilhar connosco o que estás a fazer, o que tens aprendido, etc  :)

Se chegaste até aqui podes sempre dar aqui uma olhada Part II ;)

Serial Comunication between Arduinos – With Wire & Wireless

— please check an updated code sample on the following post —


I´ve created this example to make two Arduinos talk in a simple and clear fashion.
You will see below an example with wires, and another one without wires.

– – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

Setup with TX and RX pins connected by wire:

On the sender Arduino there is a potenciometer, the values are read and sent through the serial port.
On the receiver Arduino one Led intensity will change accordingly the pot value.

Tx on Arduino#1 -> connect to ->  Rx  on Arduino#2
Rx on Arduino#1 -> connect to ->  Tx on Arduino#2

Don´t forget to disconnect Tx / Rx wires before upload


int analogValue5, val5;

void setup() {
// Serial port enable

void loop() {
// read analog pin 5
analogValue5 = analogRead(5);

// remap values from the analogValue5 variable to 0 / 255
val5 = map(analogValue5, 0, 1023, 0, 255);

// send the value to the serial port
Serial.println(val5, BYTE);


– – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –


byte incomingByte;

void setup() {
// Serial port enable

// declare pin 11 as output, this is the LED
pinMode (11, OUTPUT);

void loop() {

// if there is bytes available coming from the serial port
if (Serial.available()) {

// set the values to the ‘incomingByte’ variable
incomingByte =;

// write the value to the pin 11
analogWrite(11, int(incomingByte));


– – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –
– – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –
– – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –

Wireless setup with XBee modules:

Recently I got two XBee modules, and here is the setup to make them talk to each other:
As a start I used 2 potenciometers to control the intensity of two LEDs and It works pretty well.  :]

I´m using this adapters to connect the XBee to the circuit. They are very simple to assemble and to use.

– – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –


int analogValue2, analogValue5, val2, val5;

void setup()
// start serial port at 19200 bps

void loop()
// read analog input
analogValue2 = analogRead(2);
analogValue5 = analogRead(5);

// remap values

val2 = map(analogValue2, 0, 1023, 253, 0);  // 254 and 255 for SYNC
val5 = map(analogValue5, 0, 1023, 253, 0);

Serial.print(254, BYTE); //SYNC char
Serial.print(val2, BYTE);

Serial.print(255, BYTE); //SYNC char
Serial.print(val5, BYTE);


– – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – – –


byte incomingByte, sensor1, sensor2;

void setup() {

// start serial port at 19200 bps

// led pins

pinMode (5, OUTPUT);
pinMode (6, OUTPUT);



void loop() {
if (Serial.available()) {   // are there any bytes available on the serial port ???

// assign bytes to the var ‘incomingByte’
incomingByte =;


// from now on is pretty clear I guess   :)

if ((int(incomingByte) == 254)) {
sensor1 =;
Serial.print(“Sensor 1 = “);

if ((int(incomingByte) == 255)) {
sensor2 =;
Serial.print(“  Sensor 2 = “);

analogWrite (5, sensor1);
analogWrite (6, sensor2);

Robot Fácil com Arduino – 1ª Parte



Aqui vai a tradução à muito esperada deste tutorial, espero que vos seja útil.

Decidi remover a Ponte-H, o motor agora está directamente ligado às pilhas AA e o Arduino é alimentado por uma pilha de 9V. Este pequeno robot apenas anda em frente (para já).

Na 2ª parte vou adiccionar a Ponte-H e dois botões Bump. Assim o nosso pequeno robot poderá evitar obstáculos mudando de direcção.


Olá! E bem-vindos(as) ao tutorial Primeiro Robot com Arduino 1ª Parte !
Convém ler esta informação antes, menciona a importância de documentar o vosso processo criativo, e o processo de construção do vosso robot. Assim vocês poderão um dia mais tarde recordar o que fizeram e outros também podem vir a aprender com a vossa experiência.


1 – Introdução
2 – Antes de começar
3 – Lista de componentes
4 – Olá Hardware!
5 – Processo de construção
5.1 – Primeiro carro
5.2 – Segundo carro
5.3 – Motor servo e rodas da frente
5.4 – Baterias
5.5 – O Circuito
5.6 – O servo
5.7 – Sensor LDR (Light Dependant Resistor) – Fotoresistência
6 – Programação


1 – Introdução

Neste tutorial verás que não precisas ser nenhum guru electrónico ou um super engenheiro para fazeres um robot simples e divertido.

Este robot não terá nenhum sensor de ultrasons ou infra-vermelho.

Que vai este robot fazer?..  poderás tu perguntar..
Este robot será um procurador da Luz!!

Se decidires seguir este tutorial, deverás estár mais ou menos familiarizado com uma breadboard, com ferro de soldar e se possível saber usar uma pistola de cola quente.


2 – Antes de começar


Alguma vez usaste uma BREADBOARD, também conhecida como Placa de Ensaios ?

Tens aqui um tutorial simples de como funciona:


Na secção 4 vou mostrar como se lê entradas analógicas e como trabalhar com um motor servo, mas..

Se não sabes:
–    como fazer piscar um LED;
–    ler e interpretar uma entrada analógica, por exemplo ligada a um potenciómetro;
–    usar o comando Serial;
–    entender os principio básicos de OOP (Object Oriented Program).

Aconselho uma visita aos seguintes links:

Getting Started with Arduino

Estes tutorials são muito acessíveis:


Dá sempre um passo a seguir ao outro. Sempre que montas algo testa o que fizeste, e se for bem sucessido passa para o próximo passo.
Esta é uma boa prática e faz com que poupes tempo e paciência preciosos.


3 – Lista de componentes:

Componentes gerais:

1 Arduino Diecimila ou Duemilanove
1 Breadboard (placa de ensaios)
1 Servo
2 LDR (Light Dependant Resistance)
2 Resistências 10k
2 Botões On / off
5 – Resistências de 1 Ohm  (isto vai depender da potência do motor do teu carro)
Fios condutores (coloridos se possivel)

Components customizáveis::

Baterias – vai depender das necessidades do teu motor

Eu vou usar:

1 pilha de 9V com ligação ao Arduino
3 AA NiMh para alimentar o motor


Escolhi usar brinquedos em vez de components pré-feitas. É mais rápido obtê-los são baratos e é divertido usá-los para fins diferentes dos quais foram concebidos. A outra razão é que aumenta a tua capacidade criativa e habituaste a procurar soluções onde aparentemente não existem.


Numa loja de produtos chineses encontram-se imensos brinquedos baratos que esperam por ser vandalizados  :]

Este carrinho foi 5€ e vou usá-lo como plataforma e chassis

Este carrinho foi 2€ e vou usar as rodas da frente apenas para a direcção.


4 – Olá Hardware:

LDR – Light Dependant Resistors – Fotoresistências

Esta parte é para iniciantes em Arduino, vou mostrar sucintamente como se move um motor servo e como se lê entradas analógicas ligadas às fotoresistências (LDR).

This part is for beginners in Arduino, I will show briefly how to move a servo, and read analog inputs through LDR´s.


Ler entrada analógica ligada ao LDR:

O LDR pode ser montado em qualquer direcção, isto significa que não tem polaridade ( + ou – ). O mesmo acontece com as resistências.


Segue esta imagem, e puxa um fio para a entrada analógica no Arduino.



Agora para o Servo:

Antes de usares o código para o servo, precisas de instalar a livraria Servotimer1. Do ficheiro ZIP extraí o seu conteúdo para a pasta hardware/libraries dentro da pasta do Arduino. Reinicia o software do Arduino.

Puxa o frio Preto que vem do servo e liga à linha preta na breadboard, o fio Vermelho liga à linha vermelha na breadboard, e o fio Amarelo ao pin digital 9 no Arduino.

Puxa mais dois fios e liga os 5V no Arduino à linha Vermelha na Breadboard, e o GND no Arduino à linha preta na Breadboard.

O Arduino vai ser alimentado pelo cabo USB.


Agora que estás mais familiarizado com bites e bytes do Arduino, VAMOS DAR INÍCIO À FESTA  :D


5 – Processo de Montagem

5.1 – Primeiro Carro

Desmonta o carro que vai ser a plataforma e chassis aos components e ao sistema de tracção, ou seja, remove todas as partes excepto as rodas de trás e o seu motor.

Solda um fio a cada um dos pins do motor.

Também soldei um fio preto ao Ground e um fio vermelho à botão on/off que liga à caixa das pilhas.

Esta foi a primeira e última vez que viste solda neste tutorial. :)


5.2 – Segundo Carro

Outro pequeno carrito foi vandalizado, desta vez vou usar as rodas da frente para a direcção.


5.3 – Motor Servo e Rodas da Frente:

Colei as rodas ao Servo, não está um trabalho bonito eu sei.. tenta centrar as rodas o melhor que puderes em relação ao servo.

Depois usei cola quente para colar o servo ao chassis.

ATENÇÃO: Certifica-te que ambas as rodas tocam no chão ou então terás problemas.

A roda da esquerda não toca no chão = PROBLEMA

Ambas as rodas tocam no chão = Problema resolvido       : ]


5.4 – Batterias

Tive sorte com este pequeno carrito. A pilha de 9V encaixa perfeitamente dentro do chassis, e posso usar o compatimento das 3 pilhas AA, e assim poupo espaço para a breadboard no topo do chassis.


5.5 – O circuito

O Arduino é alimentado através da pilha de 9V.
Os fios preto e vermelho ligam o Ground e os 5V do Arduino às filas principais da breadboard.

Agora liga o fio vermelho que vem das baterias AA a uma coluna na breadboard.

Agora eu estou a usar cinco resistências de 1 ohm entre o motor e as 3 baterias AA.

Estas resistências são de baixa intensidade mas são suficientes para reduzir a rotação do motor, o suficiente para este não queimar.

Eu podia usar apenas uma resistência de 5 ohm, mas se usar cinco resistências de 1 ohm tenho mais precisão na velocidade do meu motor. Neste caso se eu quizer aumentar ou reduzir a potência só terei que adiccionar ou remover uma resistência.

Assim o motor não queima e consigo obter uma boa relação velocidade / potência

Nota que o fio do Ground está ligado a outra fileira na breadboard.

À fileira do ground ligo um fio que vai para o motor, à fileira da última resistência ligo o outro fio do motor.

Liga o botão on/off das baterias AA e vê se o motor funciona e se tem força suficiente para mover o teu carrito futuro robot.


5.6 – O Servo

Liga o Servo à breadboard.

Pega em dois fios e liga o vermelho e o preto do servo às fileiras principais na breadboard.
Pega noutro fio e liga o amarelo ao pin digital 9 no Arduino.


5.7 – LDR – Fotoresistências

Último passo

Monta o LDR e as resistências, estes não têm + nem -, por isso podes montá-los em qualquer direcção.

Os fios verdes ligam aos pins analógicos no Arduino 4 e 5.


(testa os LDR como fizeste anteriormente)

Este é o aspecto final do circuito.
Ok, todos os passos físicos estão feitos, agora só falta fazer upload da programação para o Arduino.


6 – Programação!!!

Robot Program


Fiz umas antenas para os LDR, assim as variações de luz são mais evidentes para o comportamento do nosso robot.



Espero que este tutorial vos tenha sido útil! E espero também ver os vossos robots em breve.   ;)

5 . Fev . 2009

Só para dizer que já não vai mais haver Part 2.

Eu cheguei a completá-la, mas as os fios e as ligações são tantas, e o resultado final é muito fraquinho..

aqui ficam os meus pedidos de desculpa para aqueles que ficaram à espera, no entanto a intenção foi boa..  :)