quinta-feira, 8 de setembro de 2011

Tutorial: Parte 3

Componentes necessários: 

1x LED
1x Resistor 470R a 1K

Nível de dificuldade:

Básico


Já sabendo como conectar o Arduino, selecionar placa e porta correta, compilar e carregar um sketch, podemos acrescentar alguns componentes externos e experimentar algumas coisas diferentes.

Primeiro, vamos aos componentes usados para essa parte do tutorial.

LED
Um LED, diodo emissor de luz, é um componente eletrônico que emite luz quando submetido a uma corrente elétrica. Outrora comuns apenas em sinalização e paíneis de aparelhos eletrônicos, controles-remoto, etc, hoje estão à disposição em uma variedade imensa de formatos, tamanhos e potência luminosa.

Para essa parte do tutorial não fará diferença o tipo, tamanho ou cor do led usado.





Resistor

A resistência elétrica é a propriedade que os materiais têm de dificultar a passagem da corrente elétrica. Um resistor é um componente com uma resistência conhecida, feito com esse propósito, de ser usado para limitar a corrente elétrica passando por determinada parte do circuito. Imagine a corrente elétrica como a água passando por um cano e a resistência elétrica como o diâmetro do cano, que determina quanta água pode passar. Uma alta resistência é análoga a um cano de pequeno diâmetro.

A resistência elétrica é medida em Ohms, com o valor dos resistores sendo marcado através de faixas coloridas seguindo um código de cores. Aprenda mais sobre isso no link abaixo. 


Para essa parte do tutorial, precisaremos de um resistor para limitar a corrente do LED. Um valor adequado para essa função é de 470 a 1000 ohms.

Circuito

O led é um componente polarizado, ou seja, tem um pino que corresponde ao positivo, o anodo,  e um ao negativo, o catodo. A identificação dos terminais certos pode ser feita de várias formas. Com leds novos, o terminal mais curto é o catodo, o mais comprido o anodo. Outra forma é através da borda do led, ausente no lado do catodo. Em último caso, basta testar no circuito e inverter caso não funcione na primeira tentativa.

Os leds também têm uma resistência muito baixa, o que significa que ao ligarmos um deles a uma bateria ou uma fonte, passará por ele uma grande corrente elétrica, que fará com que aqueça em excesso e queime, às vezes em uma fração de segundo.

Para impedir que isso ocorra e limitar a corrente elétrica que passará pelo LED é que usaremos o resistor em série com o LED. Essa é a primeira lição realmente importante desse tutorial: nunca ligue um LED sem
um resistor em série, a menos que saiba muito bem o que está fazendo... e se soubesse, você não estaria lendo isso.

A ligação que faremos será como no esquema abaixo. O catodo do led será ligado ao GND da placa. O anodo será ligado a um dos pinos do resistor e o outro pino do resistor será ligado ao pino 9 do Arduino.


O que temos nesse circuito é o mais simples possivel: quando elevarmos o sinal de saida do pino 9 o led acenderá. Vamos fazer isso então...


Código

Primeiro, vamos aproveitar o código da parte 2. Nele fizemos com que o led embutido na placa do Arduino e ligado internamente ao pino 13 piscasse a cada 2 segundos. Para usá-lo aqui basta mudarmos o pino que está sendo usado, do 13 para o 9.


int ledPin =  9;    // LED conectado ao pino 9
 
// A função setup() é executada uma vez quando o programa inicia
void setup()   {                
// inicializa o pino como uma saída digital
pinMode(ledPin, OUTPUT);     
}

// a função loop() é executada continuamente, enquanto o Arduino 
// estiver ligado
void loop()                     
{
  digitalWrite(ledPin, HIGH);   // acende o LED
delay(1000);                  // espera 1 segundo
digitalWrite(ledPin, LOW);    // apaga o LED
delay(1000);                  // espera 1 segundo
} 


Como fizemos no exemplo anterior, vá ao menu Sketch>Compile, ou use CTRL + R, ou ainda o botão de "play" na barra de ferramentas no topo do IDE para compilar o programa. Se a compilação foi bem sucedida, basta enviar para o Arduino usando File>Upload to I/O board, ou CTRL + U, ou o botão com a seta apontando para a direita na barra de ferramentas.

Lembre-se que se o upload falhar, você pode ter selecionado a placa ou a porta errada anteriormente, ou há algum outro problema, e haverá uma mensagem de erro.

Se tudo correu bem, o LED conectado ao resistor deve começar a piscar a cada segundo.

Na próxima parte mostrarei como usar um pino como entrada digital.

domingo, 8 de maio de 2011

Tutorial: convertendo servo para rotação contínua

Já faz um bom tempo que parei de usar motores DC com caixa de redução para meus robôs, dando preferência a servos convertidos para rotação contínua. A principal vantagem é a simplicidade do circuito de controle. Mesmo quando a intenção é conectar diretamente a um outro circuito de controle, tenho usado os servos removendo toda a parte eletrônica e ligando diretamente ao motor. A vantagem sobre um motor DC comum nesse caso é a padronização do tamanho e a facilidade de conectar as partes, usando as peças de fixação dos servos.

A grande desvantagem é que a maioria dos servos baratos costuma ter engrenagens de plástico e pouco torque. Encontrei a solução para esse problema com o Tower Pro MG995 e 996. São servos baratos, na faixa de US$ 10-15, com engrenagens de metal, rolamentos e torque de sobra para a maioria das aplicações onde usaria um motor DC com caixa de redução na mesma faixa de preço.






Atendendo ao pedido de um amigo, vou documentar aqui o procedimento para converter qualquer um dos dois para rotação contínua. Não é muito diferente do procedimento usado para qualquer outro servo, mas a caixa de redução e as engrenagens de metal podem intimidar um pouco à primeira vista.


O primeiro passo é abrir o servo, retirando os parafusos da tampa traseira com uma chave philips.


Depois de retirar a tampa traseira, com muito cuidado retire a tampa superior. Há um pino que serve de eixo para as engrenagens centrais, mas como ele não é fixo nem à tampa, nem à base, ele pode escapar quando você abre e cair. Muito cuidado para não perdê-lo nesse momento. Recomendo que retire a tampa dentro de uma caixinha ou pote plástico para que qualquer peça caia ali dentro.



Com muito cuidado, retire a engrenagem central. Com mais cuidado ainda retire a engrenagem do eixo do servo (à esquerda na foto acima). Essa engrenagem é presa ao potênciometro interno do servo, e pode exigir um pouco de força para sair. Uma chave de fenda puxando aos poucos por baixo ajuda muito.


Note como a engrenagem do eixo tem um pino limitador. Retirá-lo é a parte mais difícil da conversão. Com um alicate pequeno segure-o com força, puxando para cima e girando para os lados. Você deve conseguir senti-lo se movendo e então retirá-lo sem muito trauma.


Uma vez removido o pino, pode recolocar as engrenagens e a tampa no lugar. Tudo deve encaixar com precisão, sem forçar nada no lugar. Depois de remontar a caixa de redução, use uma das rosetas de fixação como alavanca para girar um pouco o servo e confirmar que tudo está montado corretamente. Mesmo sem o pino você deve sentir um limite devido ao potênciometro.


Depois de remontar a caixa e confirmar que tudo está no lugar, recomendo prender a tampa superior com uma fita adesiva ou etiqueta fácil de remover, apenas para evitar que tudo abra de novo enquanto você estiver alterando o circuito.

Tire a plaquinha do circuito e sob ela você verá o potênciometro, preso ao lugar por um parafuso e cola-quente (Made in China). Remova a plaquinha e o parafuso e tire o potênciometro. Com o ferro de soldar, remova com cuidado os fios do potênciometro ligados à placa, limpando bem as ilhas. Não aqueça demais por muito tempo. Recomendo usar fita dessoldadora, apesar do sugador de solda na foto.


Depois de removido o potênciometro, solde dois resistores de 2k2 no lugar, formando o mesmo divisor de tensão. Uma alternativa é usar um trimpot de precisão de 5k, mas não é uma grande vantagem já que a regulagem pode ser feita no software.

Com cuidado coloque a plaquinha no lugar, recoloque a tampa e os parafusos e o trabalho está pronto. Agora basta conectar ao Arduino e encontrar o ponto exato em que o servo fica parado. Comece com 1500 microsegundos e ajuste para cima ou para baixo até que ele pare de se mover.

sábado, 11 de dezembro de 2010

Demo: DS1307

O DS1307 é um circuito integrado com um relógio (RTC) que fornece uma solução simples para circuitos que precisem marcar a passagem de tempo ou mostrar as horas. De baixíssimo consumo, permite manter a contagem do tempo mesmo com o circuito principal desligado através de uma bateria de backup. A comunicação com o circuito é feita através de I2C.

O único componente externo necessário é um cristal de 32.768kHz para o oscilador. Caso não consiga encontrá-lo à venda, ele existe em praticamente qualquer circuito que tenha um relógio, desde relógios de pulso baratos até placas-mãe de computadores. Não é difícil encontrá-los em sucata. O cristal deve ser soldado o mais próximo possível do circuito integrado, com o invólucro metálico eletricamente ligado ao terra.

O DS1307 também tem um pino de saída que fornece um sinal de onda quadrada ajustável para várias frequências. Pode ser útil no caso de um relógio, por exemplo, quando desejamos piscar um led a cada segundo.



#include <Wire.h>
// endereço I2C do DS1307
#define DS1307_I2C_ADDRESS 0x68

// cria as variáveis para armazenar os valores
// SS[0-60], MM[0-60], HH[0-24], D[1-7], DD[1-31], MM[1-12], YY[00-99]
byte second, minute, hour, dayweek, day, month, year; 

char buffer[50]; // buffer para armazenar entrada serial
 
 
void setup() {
  Wire.begin(); // inicializa interface I2C
  Serial.begin(9600); // inicializa serial
  
}

void loop() {
  if (Serial.available()) {
    fillBuffer();
    setDateDS1307();
  }
   
  getDateDS1307(); // pega a hora atual e armazena
  writeSerial(); // envia a hora pela serial

  delay(500);
} 
  
// converte binário para BCD
byte dec2bcd(byte val){
  return ((val/0xA*0x10)+(val%0xA));
}

// converte BCD para binário
byte bcd2dec(byte val){
  return ((val/0x10*0xA)+(val%0x10));
}

// converte dois dígitos ASCII da entrada em um único byte
byte digitToByte(int x,int y){
  return (byte) ((buffer[x]&0x0F)*10+(buffer[y]&0x0F));
}

// converte caracteres ASCII da entrada em um byte com o dia da semana
byte dayToByte(int x,int y, int z){
  int temp = buffer[x]+buffer[y]+buffer[z];
  switch(temp){
    case 0x12A: return (byte) 1; break; // Mon
    case 0x12E: return (byte) 2; break; // Tue
    case 0x120: return (byte) 3; break; // Wed
    case 0x131: return (byte) 4; break; // Thu
    case 0x121: return (byte) 5; break; // Fri
    case 0x128: return (byte) 6; break; // Sat
    case 0x136: return (byte) 7; break; // Sun
    default: return (byte) 0;
    }
}

// converte caracteres ASCII da entrada em um byte com o mês
byte monthToByte(int x,int y, int z){
  int temp = buffer[x]+buffer[y]+buffer[z];
  switch(temp){
    case 0x119: return (byte) 1; break; // Jan
    case 0x10D: return (byte) 2; break; // Feb
    case 0x120: return (byte) 3; break; // Mar
    case 0x123: return (byte) 4; break; // Apr
    case 0x127: return (byte) 5; break; // May
    case 0x12D: return (byte) 6; break; // Jun
    case 0x12B: return (byte) 7; break; // Jul
    case 0x11D: return (byte) 8; break; // Aug
    case 0x128: return (byte) 9; break; // Sep
    case 0x126: return (byte) 10; break; // Oct
    case 0x133: return (byte) 11; break; // Nov
    case 0x10C: return (byte) 12; break; // Dec
    default: return (byte) 0;
    }
}

// lê dados da serial para o buffer de entrada
void fillBuffer(){
  delay(500); 
  int ptr =0;
  buffer[ptr++]=Serial.read();
  while(Serial.available() > 0) {
    buffer[ptr++]=Serial.read();
    if(buffer[ptr]=='/n'){
      break;
    }
  }
} 

// acerta a hora do DS1307 usando como entrada um pipe do comando date.
// Sat Dec 11 12:04:12 BRST 2010
void setDateDS1307(){
   second=digitToByte(17,18);
   minute=digitToByte(14,15);
   hour=digitToByte(11,12);
   dayweek=dayToByte(0,1,2);
   day=digitToByte(8,9);
   month=monthToByte(4,5,6);
   year=digitToByte(27,28);
   
   Wire.beginTransmission(DS1307_I2C_ADDRESS);
   Wire.send(0x00);
   Wire.send(dec2bcd(second));
   Wire.send(dec2bcd(minute));
   Wire.send(dec2bcd(hour));
   Wire.send(dec2bcd(dayweek));
   Wire.send(dec2bcd(day));
   Wire.send(dec2bcd(month));
   Wire.send(dec2bcd(year));
   Wire.endTransmission();
}

// pega a data e hora do DS1307
void getDateDS1307(){
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.send(0x00);
  Wire.endTransmission();

  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
  second=bcd2dec(Wire.receive() & 0x7f);
  minute=bcd2dec(Wire.receive());
  hour=bcd2dec(Wire.receive() & 0x3f);
  dayweek=bcd2dec(Wire.receive());
  day=bcd2dec(Wire.receive());
  month=bcd2dec(Wire.receive());
  year=bcd2dec(Wire.receive());
}


// envia a data e hora para a portal serial
void writeSerial(){
  Serial.print(hour, DEC);
  Serial.print(":");
  Serial.print(minute, DEC);
  Serial.print(":");
  Serial.print(second, DEC);
  Serial.print("  ");
  Serial.print(day, DEC);
  Serial.print("/");
  Serial.print(month, DEC);
  Serial.print("/");
  Serial.print(year, DEC);
  Serial.println();
}


Datasheet: http://pdfserv.maxim-ic.com/en/ds/DS1307.pdf

segunda-feira, 18 de outubro de 2010

Projeto: rover com suspensão rocker-bogie

Um dos meus projetos mais antigos mas ao mesmo tempo mais parados é o de um rover autônomo que conseguisse navegar sozinho por longas distâncias. A meta era conseguir ao menos uma volta no quarteirão, sem marcação de qualquer tipo, vencendo os obstáculos do caminho. Tempo não era questão, poderia demorar horas se preciso.

Tendo todos os componentes para a navegação à disposição, GPS, sensores e câmera, a grande questão que surgiu foi o design da parte mecânica. Em mais de um ano testando designs e partes diferentes, optei por usar uma suspensão rocker-bogie, semelhante ao design dos rovers da NASA.
 
A animação abaixo ilustra o funcionamento dessa suspensão.


Um dos desafios com robôs autônomos com rodas é enfrentar obstáculos. Por regra, um robô com rodas e sem suspensão não consegue ultrapassar obstáculos de altura maior do que o raio da roda. Como um obstáculo que esse robô com certeza terá de enfrentar são as guias das garagens e a calçada, caso tenha de descer, qualquer design tinha de levar isso em conta.

Deixando de lado a parte chata envolvida, a suspensão rocker-bogie facilita isso garantindo que todas as rodas mantém contato com o solo. Enquanto uma roda está subindo o obstáculo, as outras fornecem mais tração ajudando a "escalada". Quando a roda frontal e central chegam ao topo, elas ajudam a roda traseira a subir. O corpo é ligado à suspensão em apenas um ponto, preso por um diferencial, garantindo que mantém uma inclinação média em relação ao resto do rover.

Esse design é simples e eficiente, podendo ser construído sem molas ou amortecedores de qualquer tipo. Por outro lado, todas as rodas têm motores, e as rodas frontais e traseiras precisam de servos de controle para virar.



Depois de três protótipos com tubos de PVC para testar a idéia, esse é o estado atual do rover. As rodas de automodelismo com 10cm de diâmetro têm pneu de borracha, fornecendo ótima tração. Dentro de cada uma há espaço mais do que suficiente para embutir um servo de tamanho padrão convertido para rotação contínua. As rodas frontais e traseiras têm os servos de controle e conseguem virar cerca de 120°. O diferencial que liga ao corpo consegui de um carrinho de controle remoto de brinquedo e funciona perfeitamente para o fim.

O corpo foi construído de polietileno de alta-densidade e perfis de alumínio reforçando partes críticas. Decidi construí-lo mais alto do que o normal para facilitar passar por obstáculos pequenos ao invés de precisar escalá-los ou contorná-los.

Infelizmente cometi uma falha de design que provavelmente vai exigir correções complicadas, mas quero vê-lo andando assim e avaliar o quão bem funciona.

Apesar de não ter um vídeo do protótipo antigo em movimento, creio que a foto abaixo ilustra melhor a idéia. As caixas empilhadas alteram a altura sob cada roda, mostrando como todas mantém contato com o chão independentemente disso.


O Arduino estará no limite para este projeto. Dos pinos digitais, 0 e 1 serão para o GPS, 2-7 com os servos de movimentação, 8-11 com os servos de direção e os outros para i2C e sensores. Estou considerando a possibilidade de colocar outro Atmega 328 separado comunicando via i2c apenas para sensores de contato e acelerômetro.

Projeto: robô hexápode

Meu último projeto com Arduino Mega é este robô hexápode. Com 3 graus de movimento em cada perna, ele é capaz de realizar movimentos bem complexos.



Apesar do microcontrolador de 8 bits limitar bastante o movimento por não ser muito adequado aos cálculos de cinemática reversa, apenas com tabelas de lookup é possível implementar vários gaits e realizar movimentos interessantes.




O corpo foi construído em polietileno de alta densidade. Os servos são 12 TowerPro MG995, com engrenagens de metal e alto torque, e 6 TowerPro SG5010. Não são a melhor alternativa, mas em um país onde paga-se 100% de imposto em produtos importados sem equivalente nacional, é o melhor que pude encontrar dentro do orçamento que tinha.

A comunicação é feita por um módulo XBee 2.5 de 2mW, ligado ao Arduino Mega com um shield do sparkfun.com. Na foto ele está com uma bateria de NiMh de 1800mAh, mas o robô já está com baterias de íons de lítio com 2400mAh.

O vídeo abaixo mostra alguns dos gaits já programados, incluindo alguns tropeços.




A idéia é em breve substituir o Arduino Mega por um microcontrolador STM32F103 de 32 bits, capaz de realizar os cálculos trigonométricos necessários para cinemática reversa em tempo real, além de melhor monitorar o contato das patas com o solo.

terça-feira, 12 de outubro de 2010

Demo: HMC6352

O HMC6352 é uma bússola digital que fornece uma solução simples e de baixo custo para aplicações como robôs e sensores remotos. Com a comunicação feita por I2C, a utilização é bem simples, com os dados de orientação já prontos para uso e resolução de 0.5 grau.

Para este demo usei a placa do Sparkfun.com ligada diretamente ao Arduino Duemilanove com os pinos de SCL e SDA conectados ao analog 5 e 4 respectivamente, sem resistores de pull-up.

O endereço i2c do HMC6352 é 0x42, mas como a lib Wire do Arduino  usa endereços de 7 bits ele é ajustado para 0x21.

Apesar de ter várias instruções para calibrar, salvar e recuperar valores da memória, a única instrução usada para obter os dados é o byte 'A'.


#include <wire.h> 

// endereço do HMC6352 já ajustado para 7 bits
#define ADDRESS 0x42 >> 1

int heading;


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

// inicializa o i2c
Wire.begin();
}


void loop()
{
  // i2c master inicia a transmissão
  Wire.beginTransmission(ADDRESS);
  // envia o comando 'A', "get data"
  Wire.send("A");
  // encerra a transmissão
  Wire.endTransmission();
  // para responder o comando "get data" ele
  // pode demorar até 6 ms
  delay(6);

  // solicita 2 bytes
  Wire.requestFrom(ADDRESS, 2);
  if (2 <= Wire.available()){
    // ajusta o byte mais significante e soma
    heading = Wire.receive();
    heading = heading << 8;
    heading += Wire.receive();
  }   
  
  // exibe o resultado final em graus
  Serial.println(heading/10.0);

  
  delay(500);
} 


Datasheet: http://www.sparkfun.com/datasheets/Components/HMC6352.pdf

Tutorial: Parte 2

Componentes necessários: 

Nenhum :)

Nível de dificuldade:

Básico


Apesar de haver vários modelos diferentes, este tutorial assume que o leitor usa um Arduino Duemilanove ou algum "genérico" semelhante. No futuro falarei de aplicações específicas de outros modelos e até como construir um.



Para começar a  fazer algo você precisará do cabo USB para conectar o Arduino ao computador, caso ainda não tenha. É um cabo de USB tipo A para tipo B, com conectores como os da foto abaixo. Se você tem uma impressora USB, provavelmente tem um cabo desses.



Antes de conectar o Arduino é preciso instalar o ambiente de desenvolvimento. Faça o download da versão mais recente para o seu sistema operacional: http://arduino.cc/en/Main/Software

Após a instalação, conecte o cabo ao Arduino e plugue em uma porta USB. O led verde deve acender. 

No Windows, assim que o sistema operacional detectá-lo, você deve passar pela novela de sempre de instalação de drivers, mas com sorte tudo deve  instalar automaticamente. 

Com qualquer distribuição Linux recente você já terá o driver adequado no kernel, mas precisará instalar os seguintes pacotes ou seus equivalentes na sua distribuição:
  • sun-java6-jre
  • avr-gcc-c++
  • avr-gcc
  • avr-libc

Com tudo  no lugar, podemos então começar a brincar um pouco. Primeiro vamos à anatomia da placa:


Os pinos no topo numerados de 0 a 13 são entradas e saídas digitais. Estes pinos são usados para interagir com qualquer dispositivo de entrada ou saída que lida com apenas dois estados. Na parte inferior direita estão os pinos de entrada analógica. Estes são usados para ler um valor que varia e não apenas dois estados, como um controle de volume ou velocidade. Veremos mais sobre isso adiante. À esquerda destes estão os pinos de alimentação.

Se tudo estiver bem, ao conectar seu Arduino à porta USB o led verde (PWR) deve acender. Após alguns instantes o led amarelo (L) logo abaixo do pino 13 deve começar a piscar. Inicie o ambiente de desenvolvimento (IDE).




Selecione a sua placa no menu Tools>Board, "Arduino Duemilanove or Nano w/ ATmega 328". Em seguida selecione a porta correta em Tools>Serial Port. No Windows as portas aparecerão como COM X, onde X é um número arbitrário. No Linux deve aparecer como /dev/ttyUSB0, provavelmente já selecionado. Com isso você está pronto para enviar seus programas para o Arduino.

No menu File>Examples>Digital selecione Blink. Isso abrirá outra janela do IDE com o código de exemplo abaixo:


int ledPin =  13;    // LED conectado ao pino 13 
 
// A função setup() é executada uma vez quando o programa inicia
void setup()   {                
  // inicializa o pino como uma saída digital
pinMode(ledPin, OUTPUT);     
}

// a função loop() é executada continuamente, enquanto o Arduino 
// estiver ligado
void loop()                     
{
  digitalWrite(ledPin, HIGH);   // acende o LED
delay(1000);                  // espera 1 segundo
digitalWrite(ledPin, LOW);    // apaga o LED
delay(1000);                  // espera 1 segundo
} 


Essa é a estrutura básica de qualquer programa do Arduino. A função setup() deve conter o código que será executado uma vez, quando o Arduino iniciar. A função loop() será executada enquando o Arduino estiver ligado e deve conter a funcionalidade principal do programa.

O programa acima é o "Hello World" do Arduino, mas já utiliza três funções bem comuns.

A função pinMode(pino, modo) define o modo de funcionamento de um pino digital, se será usado como entrada ou saída.

A função digitalWrite(pino, valor) altera o nível de saída do pino de acordo com o desejado. Note que para isso é preciso que o pino tenha sido configurado como saída anteriormente usando a função pinMode.

A função delay(ms) faz com que o Arduino espere um determinado período de tempo definido em milissegundos antes de continuar a execução do programa.


Vá no menu Sketch>Compile, ou use CTRL + R, ou ainda o botão de "play" na barra de ferramentas no topo do IDE para compilar o programa. Se a compilação falhar e você não tiver feito nenhuma alteração, provavelmente há algo de errado com a sua instalação e haverá uma mensagem de erro no buffer preto na parte inferior do IDE.

Se a compilação foi bem sucedida, basta enviar para o arduino. Vá em File>Upload to I/O board, ou use CTRL + U, ou o botão com a seta apontando para a direita na barra de ferramentas. Se tudo estiver certo, em alguns instantes os dois leds amarelos (TX e RX) do Arduino devem começar a piscar até que o upload de todo o programa seja feito. Se o upload falhar, você pode ter selecionado a placa ou a porta errada anteriormente, ou há algum outro problema, e haverá uma mensagem de erro.

Se tudo correu bem, o LED amarelo (L) deve começar a piscar a cada segundo.

Para este teste usamos o pino já existente na placa, mas a mesma coisa pode ser feita com qualquer outro ligando um LED e resistor externos.

Na próxima parte mostrarei como usar outros pinos da mesma forma, além de como usá-los para entrada digital.