27 agosto 2013

Shield LCD 16x2 com Keypad

O shield LCD 16x2 com Keypad (teclado) é um componente útil se quisermos montar algum tipo de painel que necessite de entrada de dados ou controle por meio de botões. Pode ser utilizado para digitar uma senha, selecionar uma opção em um menu ou até mesmo controlar os passos de um robô. As aplicações são diversas e você pode adquirir o seu diretamente na Loja FILIPEFLOP.

shield lcd 16x2 Arduino

Este shield possui um display LCD 16x2 com backlight (luz de fundo) azul, e 5 botões customizáveis, além de um botão de reset do Arduino. O ajuste do contraste é feito pelo parafuso do trimpot/potenciômetro acima do display, à esquerda (em azul). Além disso, a placa possui furos para soldagem de barras de pinos, cuja função veremos em breve.

O shield utiliza alguns pinos diferentes dos que usamos normalmente nos projetos para ligar um LCD. Se na ligação de um LCD 16x2, como mencionado no artigo Display Lcd Winstar WH1602A, eu tenho total liberdade para trocar as portas ligadas ao display, nesse shield teremos que usar a seguinte sequência ao inicializar a biblioteca LiquidCrystal :

LiquidCrystal lcd(8,9,4,5,6,7); 

Desta forma, temos a seguinte relação entre os pinos do Arduino e os sinais do display :

Ligacao Arduino - Display LCD Keypad

Os botões do shield usam uma única porta analógica, A0. Repare na ilustração abaixo que o shield usa uma associação de resistores para determinar qual botão foi pressionado, e com isso há uma grande economia de portas digitais do Arduino :
Circuito resistores - botões shield keypad

Isso tudo faz com que, obviamente, não possamos utilizar essas portas para outras funções enquanto estivermos utilizando o shield. Note no detalhe das imagens abaixo, que a placa possui furos que permitem a soldagem de uma barra de pinos ou conectores, com isso podemos usar os pinos que sobraram : 0, 1, 2, 3, 11, 12, 13 (digitais), e A1, A2, A3, A4, A5 (analógicos), além dos pinos de energia (5v, 3.3v, GND). O pino 10 também é utilizado pela placa para uma função específica, no caso o backlight, e não deve ser utilizado nos programas. 

Detalhe portas digitais

Detalhe portas analogicas e energia shield keypad

Para o programa de teste, não é necessário o uso de nenhuma biblioteca especial. Usaremos a já conhecida LiquidCrystal, e para determinar qual botão foi pressionado, faremos a leitura da porta analógica A0 :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
// Programa : Teste LCD 16x2 com Keypad
// Autor : Arduino e Cia
  
#include <LiquidCrystal.h>  
  
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);  
  
void setup()   
{  
 lcd.begin(16, 2);  
 lcd.setCursor(0,0);  
 lcd.print("Arduino e Cia");  
 lcd.setCursor(0,1);  
 lcd.print("Tecla :");  
}  
  
void loop()  
{  
 int botao;  
 botao = analogRead (0);  //Leitura do valor da porta analógica A0
 lcd.setCursor(8,1);  
 if (botao < 100) {  
  lcd.print ("Direita ");  
 }  
 else if (botao < 200) {  
  lcd.print ("Cima    ");  
 }  
 else if (botao < 400){  
  lcd.print ("Baixo   ");  
 }  
 else if (botao < 600){  
  lcd.print ("Esquerda");  
 }  
 else if (botao < 800){  
  lcd.print ("Select  ");  
 }  
}

15 agosto 2013

Módulo matriz de leds 8x8

Abordei anteriormente o uso do CI Max7219 para controle de display de 7 segmentos. Vimos que com ele é possível controlar até 8 displays de 7 segmentos por CI, e podemos ligar 8 CI's em série, ou seja, podemos utilizar o Arduino para controlar até 64 displays.

Outro uso interessante do Max7219 é o controle de matriz de leds 8x8. O uso desse tipo de matriz possibilita a montagem de painéis elaborados, onde podemos exibir números, letras e desenhos, e dependendo da configuração da matriz, mostrar tudo isso em várias formas, tamanhos e cores :


Painel de leds
Imagens : Blog Arduino Android  e Adafruit
A ligação da matriz de leds na protoboard costuma ser um pouco complexa e exige muita atenção para não danificar os componentes, principalmente a matriz de leds em si, que costuma ser um componente sensível.

Felizmente, existem módulos matriz de leds prontos para este fim, que consistem em um CI Max7219, uma matriz de leds 8x8 e alguns outros componentes, como capacitores e resistores. Pode ser encontrado em forma de kits, como esse :

modulo matriz leds 8x8
ou já montados e prontos para usar, como esse :

Módulo matriz de leds 8x8 Arduino

Repare que no lado esquedo do módulo, estão os pinos de entrada, nomeados como VCC, GND, DIN, CS e CLK. Os pinos do lado direito são utilizados para interligar vários módulos, e serão assunto para outro post. Hoje vamos ver como ligar este único módulo no Arduino e como mostrar caracteres na matriz em scroll horizontal. Fiz um pequeno vídeo de teste, onde além dos caracteres em scroll podem ser visualizadas outras figuras :



A ligação ao Arduino, da mesma forma que no post Controlando Display 7 Segmentos com o Max7219, usa apenas 3 portas da placa, o que dá bastante flexibilidade para usarmos sensores, leds, botões, etc. juntamente com o módulo :

matriz leds 8x8


 Ligação :

  • 5v do Arduíno ligado ao VCC do módulo
  • GND do Arduino ligado ao GND do módulo
  • Porta 4 do Arduino ligada ao pino DIN do módulo
  • Porta 5 do Arduino ligada ao pino CS do módulo
  • Porta 6 do Arduino ligada ao pino CLK do módulo

O programa foi baseado no livro Arduino Básico, do autor Michael McRoberts, com pequenas alterações e adaptações. Carregue o programa no Arduino alterando as linhas de mensagem, conforme indicado no final do programa, para exibir as informações que você quiser :

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
// Programa : Scrool horizontal com matriz de leds 8x8  
// Baseado no livro Arduino Basico, de Michael McRoberts  
// Alterações e comentários : Arduino e Cia  
   
#include <pgmspace.h>  
#include <TimerOne.h>  
   
int DataPin = 4;  //Ligar o pino 4 do Arduino ao DIN do modulo  
int ClockPin = 5; //Ligar o pino 5 do Arduino ao CLK do módulo  
int LoadPin = 6;  //Ligar o pino 6 do Arduinio ao pino CS/Load do módulo  
  
byte buffer[8];  
   
static byte font[][8] PROGMEM = {  
{B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000},   
{B00000100, B00000100, B00000100, B00000100, B00000100, B00000100, B00000000, B00000100},   
{B00001010, B00001010, B00001010, B00000000, B00000000, B00000000, B00000000, B00000000},   
{B00000000, B00001010, B00011111, B00001010, B00011111, B00001010, B00011111, B00001010},   
{B00000111, B00001100, B00010100, B00001100, B00000110, B00000101, B00000110, B00011100},   
{B00011001, B00011010, B00000010, B00000100, B00000100, B00001000, B00001011, B00010011},   
{B00000110, B00001010, B00010010, B00010100, B00001001, B00010110, B00010110, B00001001},   
{B00000100, B00000100, B00000100, B00000000, B00000000, B00000000, B00000000, B00000000},   
{B00000010, B00000100, B00001000, B00001000, B00001000, B00001000, B00000100, B00000010},   
{B00001000, B00000100, B00000010, B00000010, B00000010, B00000010, B00000100, B00001000},   
{B00010101, B00001110, B00011111, B00001110, B00010101, B00000000, B00000000, B00000000},   
{B00000000, B00000000, B00000100, B00000100, B00011111, B00000100, B00000100, B00000000},   
{B00000000, B00000000, B00000000, B00000000, B00000000, B00000110, B00000100, B00001000},   
{B00000000, B00000000, B00000000, B00000000, B00001110, B00000000, B00000000, B00000000},   
{B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000100},   
{B00000001, B00000010, B00000010, B00000100, B00000100, B00001000, B00001000, B00010000},   
{B00001110, B00010001, B00010011, B00010001, B00010101, B00010001, B00011001, B00001110},   
{B00000100, B00001100, B00010100, B00000100, B00000100, B00000100, B00000100, B00011111},   
{B00001110, B00010001, B00010001, B00000010, B00000100, B00001000, B00010000, B00011111},   
{B00001110, B00010001, B00000001, B00001110, B00000001, B00000001, B00010001, B00001110},   
{B00010000, B00010000, B00010100, B00010100, B00011111, B00000100, B00000100, B00000100},   
{B00011111, B00010000, B00010000, B00011110, B00000001, B00000001, B00000001, B00011110},   
{B00000111, B00001000, B00010000, B00011110, B00010001, B00010001, B00010001, B00001110},   
{B00011111, B00000001, B00000001, B00000001, B00000010, B00000100, B00001000, B00010000},   
{B00001110, B00010001, B00010001, B00001110, B00010001, B00010001, B00010001, B00001110},   
{B00001110, B00010001, B00010001, B00001111, B00000001, B00000001, B00000001, B00000001},   
{B00000000, B00000100, B00000100, B00000000, B00000000, B00000100, B00000100, B00000000},   
{B00000000, B00000100, B00000100, B00000000, B00000000, B00000100, B00000100, B00001000},   
{B00000001, B00000010, B00000100, B00001000, B00001000, B00000100, B00000010, B00000001},   
{B00000000, B00000000, B00000000, B00011110, B00000000, B00011110, B00000000, B00000000},   
{B00010000, B00001000, B00000100, B00000010, B00000010, B00000100, B00001000, B00010000},   
{B00001110, B00010001, B00010001, B00000010, B00000100, B00000100, B00000000, B00000100},   
{B00001110, B00010001, B00010001, B00010101, B00010101, B00010001, B00010001, B00011110},   
{B00001110, B00010001, B00010001, B00010001, B00011111, B00010001, B00010001, B00010001},   
{B00011110, B00010001, B00010001, B00011110, B00010001, B00010001, B00010001, B00011110},   
{B00000111, B00001000, B00010000, B00010000, B00010000, B00010000, B00001000, B00000111},   
{B00011100, B00010010, B00010001, B00010001, B00010001, B00010001, B00010010, B00011100},  
{B00011111, B00010000, B00010000, B00011110, B00010000, B00010000, B00010000, B00011111},   
{B00011111, B00010000, B00010000, B00011110, B00010000, B00010000, B00010000, B00010000},   
{B00001110, B00010001, B00010000, B00010000, B00010111, B00010001, B00010001, B00001110},   
{B00010001, B00010001, B00010001, B00011111, B00010001, B00010001, B00010001, B00010001},   
{B00011111, B00000100, B00000100, B00000100, B00000100, B00000100, B00000100, B00011111},   
{B00011111, B00000100, B00000100, B00000100, B00000100, B00000100, B00010100, B00001000},   
{B00010001, B00010010, B00010100, B00011000, B00010100, B00010010, B00010001, B00010001},   
{B00010000, B00010000, B00010000, B00010000, B00010000, B00010000, B00010000, B00011111},   
{B00010001, B00011011, B00011111, B00010101, B00010001, B00010001, B00010001, B00010001},   
{B00010001, B00011001, B00011001, B00010101, B00010101, B00010011, B00010011, B00010001},   
{B00001110, B00010001, B00010001, B00010001, B00010001, B00010001, B00010001, B00001110},   
{B00011110, B00010001, B00010001, B00011110, B00010000, B00010000, B00010000, B00010000},   
{B00001110, B00010001, B00010001, B00010001, B00010001, B00010101, B00010011, B00001111},   
{B00011110, B00010001, B00010001, B00011110, B00010100, B00010010, B00010001, B00010001},   
{B00001110, B00010001, B00010000, B00001000, B00000110, B00000001, B00010001, B00001110},   
{B00011111, B00000100, B00000100, B00000100, B00000100, B00000100, B00000100, B00000100},   
{B00010001, B00010001, B00010001, B00010001, B00010001, B00010001, B00010001, B00001110},   
{B00010001, B00010001, B00010001, B00010001, B00010001, B00010001, B00001010, B00000100},   
{B00010001, B00010001, B00010001, B00010001, B00010001, B00010101, B00010101, B00001010},   
{B00010001, B00010001, B00001010, B00000100, B00000100, B00001010, B00010001, B00010001},   
{B00010001, B00010001, B00001010, B00000100, B00000100, B00000100, B00000100, B00000100},   
{B00011111, B00000001, B00000010, B00000100, B00001000, B00010000, B00010000, B00011111},   
{B00001110, B00001000, B00001000, B00001000, B00001000, B00001000, B00001000, B00001110},   
{B00010000, B00001000, B00001000, B00000100, B00000100, B00000010, B00000010, B00000001},   
{B00001110, B00000010, B00000010, B00000010, B00000010, B00000010, B00000010, B00001110},   
{B00000100, B00001010, B00010001, B00000000, B00000000, B00000000, B00000000, B00000000},   
{B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00011111},   
{B00001000, B00000100, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000},   
{B00000000, B00000000, B00000000, B00001110, B00010010, B00010010, B00010010, B00001111},   
{B00000000, B00010000, B00010000, B00010000, B00011100, B00010010, B00010010, B00011100},   
{B00000000, B00000000, B00000000, B00001110, B00010000, B00010000, B00010000, B00001110},   
{B00000000, B00000001, B00000001, B00000001, B00000111, B00001001, B00001001, B00000111},   
{B00000000, B00000000, B00000000, B00011100, B00010010, B00011110, B00010000, B00001110},   
{B00000000, B00000011, B00000100, B00000100, B00000110, B00000100, B00000100, B00000100},   
{B00000000, B00001110, B00001010, B00001010, B00001110, B00000010, B00000010, B00001100},   
{B00000000, B00010000, B00010000, B00010000, B00011100, B00010010, B00010010, B00010010},   
{B00000000, B00000000, B00000100, B00000000, B00000100, B00000100, B00000100, B00000100},   
{B00000000, B00000010, B00000000, B00000010, B00000010, B00000010, B00000010, B00001100},   
{B00000000, B00010000, B00010000, B00010100, B00011000, B00011000, B00010100, B00010000},   
{B00000000, B00010000, B00010000, B00010000, B00010000, B00010000, B00010000, B00001100},   
{B00000000, B00000000, B00000000, B00001010, B00010101, B00010001, B00010001, B00010001},   
{B00000000, B00000000, B00000000, B00010100, B00011010, B00010010, B00010010, B00010010},   
{B00000000, B00000000, B00000000, B00001100, B00010010, B00010010, B00010010, B00001100},   
{B00000000, B00011100, B00010010, B00010010, B00011100, B00010000, B00010000, B00010000},   
{B00000000, B00001110, B00010010, B00010010, B00001110, B00000010, B00000010, B00000001},   
{B00000000, B00000000, B00000000, B00001010, B00001100, B00001000, B00001000, B00001000},   
{B00000000, B00000000, B00001110, B00010000, B00001000, B00000100, B00000010, B00011110},   
{B00000000, B00010000, B00010000, B00011100, B00010000, B00010000, B00010000, B00001100},   
{B00000000, B00000000, B00000000, B00010010, B00010010, B00010010, B00010010, B00001100},   
{B00000000, B00000000, B00000000, B00010001, B00010001, B00010001, B00001010, B00000100},   
{B00000000, B00000000, B00000000, B00010001, B00010001, B00010001, B00010101, B00001010},   
{B00000000, B00000000, B00000000, B00010001, B00001010, B00000100, B00001010, B00010001},   
{B00000000, B00000000, B00010001, B00001010, B00000100, B00001000, B00001000, B00010000},   
{B00000000, B00000000, B00000000, B00011111, B00000010, B00000100, B00001000, B00011111},   
{B00000010, B00000100, B00000100, B00000100, B00001000, B00000100, B00000100, B00000010},   
{B00000100, B00000100, B00000100, B00000100, B00000100, B00000100, B00000100, B00000100},   
{B00001000, B00000100, B00000100, B00000100, B00000010, B00000100, B00000100, B00001000},   
{B00000000, B00000000, B00000000, B00001010, B00011110, B00010100, B00000000, B00000000}   
};  
   
void clearDisplay() 
{
    for (byte x=0; x<8; x++) 
    {  
       buffer[x] = B00000000;  
    }  
    screenUpdate();  
}  
  
void initMAX7219() 
{  
    pinMode(DataPin, OUTPUT);  
    pinMode(LoadPin, OUTPUT);  
    pinMode(ClockPin, OUTPUT);  
    clearDisplay();  
    writeData(B00001011, B00000111);   
    writeData(B00001001, B00000000);   
    writeData(B00001100, B00000001);   
    intensity(1);   
}  
   
void intensity(int intensity) 
{  
    writeData(B00001010, intensity);   
}  
   
void writeData(byte MSB, byte LSB) 
{  
    byte mask;  
    digitalWrite(LoadPin, LOW);   
      
    for (mask = B10000000; mask>0; mask >>= 1) 
    {   
        digitalWrite(ClockPin, LOW);  
        if (MSB & mask)
        {   
           digitalWrite(DataPin,HIGH);   
        }  
        else
        {   
           digitalWrite(DataPin,LOW);   
        }  
        digitalWrite(ClockPin, HIGH);   
    }  
      
    for (mask = B10000000; mask>0; mask >>= 1) 
    {   
        digitalWrite(ClockPin, LOW);  
        if (LSB & mask)
        {   
           digitalWrite(DataPin,HIGH);   
        }  
        else
        {   
            digitalWrite(DataPin,LOW);   
        }  
        digitalWrite(ClockPin, HIGH);   
    }  
    digitalWrite(LoadPin, HIGH);   
    digitalWrite(ClockPin, LOW);  
}  
   
void scroll(char myString[], int speed) 
{  
    byte firstChrRow, secondChrRow;  
    byte ledOutput;  
    byte chrPointer = 0;   
    byte Char1, Char2;   
    byte scrollBit = 0;  
    byte strLength = 0;  
    unsigned long time;  
    unsigned long counter;  
       
    while (myString[strLength]) {strLength++;}  
    counter = millis();  
    while (chrPointer < (strLength-1)) 
    {  
       time = millis();  
       if (time > (counter + speed)) 
       { 
          Char1 = myString[chrPointer];  
          Char2 = myString[chrPointer+1];  
          for (byte y= 0; y<8; y++) 
          {  
            firstChrRow = pgm_read_byte(&font[Char1 - 32][y]);  
            secondChrRow = (pgm_read_byte(&font[Char2 - 32][y])) << 1;  
            ledOutput = (firstChrRow << scrollBit) | (secondChrRow >> (8 - scrollBit) );  
            buffer[y] = ledOutput;  
          }  
            scrollBit++;   
            if (scrollBit > 6) 
            {   
              scrollBit = 0;  
              chrPointer++;  
            }  
            counter = millis();  
        }  
    }  
}  
   
void screenUpdate() 
{  
   for (byte row = 0; row < 8; row++) 
   { 
      writeData(row+1, buffer[row]);  
   }  
}  
   
void setup() 
{  
   initMAX7219();  
   Timer1.initialize(10000);       
   Timer1.attachInterrupt(screenUpdate);   
}  
  
void loop() 
{  
   clearDisplay();    
   //Exibe a mensagem, com intervalo de scroll de 100
   scroll(" Arduino e Cia ", 100); 
   //Adicione mais linhas para mostrar outros caracteres
   scroll(" - 2013 ", 100);        
}  

Atualizado : Quer interligar dois ou mais módulos ? Veja o artigo Painel de Led com módulo Max7219



08 agosto 2013

Ligando uma lâmpada com relé e push button

Neste artigo anterior sobre como ligar uma lâmpada utilizando relé, eu mostrei como ligar um relé ao Arduino, utilizando transistor, diodo e resistor. O programa exemplo acionava o relé, aguardava 5 segundos, desligava o relé, aguardava mais 5 segundos, e repetia o processo.

Seguindo a sugestão de alguns leitores, vou usar o mesmo circuito como base, e mostrar o acionamento do relé via push button, ou seja, cada vez que o botão é pressionado, o estado do led é alterado, acendendo e apagando conforme o controle do usuário. Veja no vídeo abaixo o circuito em funcionamento :



Antes do circuito, vamos apenas recapitular a "lista de material" que utilizei anteriormente :

  • Rele 5v
  • 1 Diodo 1N4007 (ou similar)
  • 1 Transistor BC548 (ou equivalente NPN)
  • 2 resistores de 10 K
  • Led

e vamos acrescentar :

  • 1 push button
  • 1 resistor 330 ohms

Com o material em mãos, vamos ao circuito, que como citei anteriormente, é o mesmo do artigo anterior, agora com um push button ligado à porta 2 do Arduino :

Circuito Arduino Relé push button
Também usei o programa anterior como base, acrescentando uma rotina que inverte o estado do relé conforme o botão é pressionado :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// Programa : Acionamento de rele utilizando push button
// Autor : Arduino e Cia

int sinalparaorele = 4; //define a porta para o acionamento do rele
int pinobotao = 2;    //Porta utilizada para o botão de acionamento
int leitura;          //Armazena informações sobre a leitura do botão
int estadorele = 0;   //Armazena o estado do relé (ligado/desligado)

void setup()
{
  //Define o pino como saida (sinal para o rele)
  pinMode(sinalparaorele, OUTPUT); 

  //Define o pino como entrada (Pino do botao)
  pinMode(pinobotao, INPUT);      
  // digitalWrite(sinalparaorele, 0);
}

void loop()
{
  leitura = digitalRead(pinobotao);
  if (leitura != 1)
  {
    while(digitalRead(pinobotao) != 1)
    {
      delay(100);
    }
    // Inverte o estado
    estadorele = !estadorele;
    digitalWrite(sinalparaorele, estadorele);  
  } 
}

E finalmente, se você precisar utilizar este mesmo esquema e programa para acionar uma lâmpada, use a ligação abaixo :

Circuito Arduino relé lâmpada
Essa é apenas uma opção de uso de botão para acionamento do relé. Conforme as suas necessidades, o botão pode ser facilmente substituído por uma chave, um sensor ou a entrada pode até mesmo ser acionada via bluetooth, como neste artigo, onde explico como utilizar um celular Android para controlar o Arduino, via bluetooth.


02 agosto 2013

Código de cores de resistores

Um componente muito utilizado nos circuitos do Arduino são os resistores. Eles são utilizados principalmente para limitar a corrente em determinadas partes do circuito, evitando queima de  outros componentes como leds, circuitos integrados e displays.

Se usarmos um led, por exemplo, que trabalha com 2 volts, e ligarmos esse led diretamente nos 5 volts do Arduino, provavelmente iremos danifica-lo. O uso de uma resistência em série com o led limita a corrente no componente, evitando a queima do mesmo, como nesse pequeno exemplo :

codigo de cores resistor
 A maior parte dos leds é identificada por um código de cores, como este resistor de 560 ohms :

Resistor 560 ohms
Foto : Pictronix
E como eu sei que este resistor é de 560 ohms ? Usando uma tabela, como esta abaixo, que relaciona cada cor de faixa com um valor :

Tabela de codigo de cores de resistores
Imagem : Solusweb

Verificando a resistência e a tabela, vemos que :

1a. faixa - Verde - valor 5
2a. faixa - Azul - valor 6
3a. faixa - Marrom (multiplicador) - x10 ohms
4o. faixa - Dourado (tolerância) - +/-5%

O que nos dá o valor de 560 ohms.

Se você precisa de um método mais rápido e mais fácil do que ficar olhando uma tabela ou decorando valores, pode usar uma calculadora online, como esta do site Searchingtabs :

calculador online resistores

Num primeiro momento o layout parece um pouco confuso, mas o uso é bastante simples. Você pode clicar nas setas e escolher a cor de cada faixa, e o valor da resistência vai sendo mostrado na parte de baixo, na caixa "resultado" (destacado em amarelo).

Também é permitido fazer o contrário, ou seja, digitar o valor da resistência na caixa resultado, e a página se encarrega de mostrar o resistor com as cores correspondentes. Fácil, não ?