Social Icons

4.12) Display 7 Segmentos

No meio de um experimento com Display de 7 seguimentos e Arduino, achei melhor criar uma classe para tratar dos números exibidos no Display.


Deixo aqui a Classe e um exemplo de como usá-la.
Configuração de pinos (Digital) utilizada no exemplo:
7 Segments LED Display - Pin Configuration
Obs.: Está configuração pode ser modificada no momento em que é criada a instância da classe “Simple7Segments” (Simple7Segments display(2, 3, 4, 5, 6, 7, 8, 9);).


Simple7Segments.h (biblioteca)

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
/**
 * Simple seven segments LED display
 *
  */


#ifndef Simple7Segments_h
#define Simple7Segments_h


#include <inttypes.h>


class Simple7Segments
{
  private:
    uint8_t *_pins;
    uint8_t _count;
 
  public:
    Simple7Segments(uint8_t, uint8_t, uint8_t, uint8_t,
      uint8_t, uint8_t, uint8_t, uint8_t);
    void showNumber(char);
    void showAll();
    void clearAll();
};


#endif



Simple7Segments.cpp
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
/**
 * Simple seven segments LED display
 *
 */


#include "Simple7Segments.h"
#include "WProgram.h"


#include <inttypes.h>


#define QUANTITY_PINS 8


Simple7Segments::Simple7Segments(uint8_t a, uint8_t b, uint8_t c, uint8_t d,
  uint8_t e, uint8_t f, uint8_t g, uint8_t pd)
{
  // Alocate memory for Array _pins
  _pins = (uint8_t*)calloc(QUANTITY_PINS, 4);
 
  // Transfer parameters to array pins
  _pins[0] = a;
  _pins[1] = b;
  _pins[2] = c;
  _pins[3] = d;
  _pins[4] = e;
  _pins[5] = f;
  _pins[6] = g;
  _pins[7] = pd;
 
  // Set pin mode to all
  for (_count = 0; _count < QUANTITY_PINS; _count++)
  {
    pinMode(_pins[_count], OUTPUT);
  }
}


void Simple7Segments::showNumber(char letter)
{
  clearAll();
  switch (letter)
  {
    case '0':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[2], HIGH);
      digitalWrite(_pins[3], HIGH);
      digitalWrite(_pins[4], HIGH);
      digitalWrite(_pins[5], HIGH);
    break;
    case '1':
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[2], HIGH);
    break;
    case '2':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[6], HIGH);
      digitalWrite(_pins[4], HIGH);
      digitalWrite(_pins[3], HIGH);
    break;
    case '3':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[6], HIGH);
      digitalWrite(_pins[2], HIGH);
      digitalWrite(_pins[3], HIGH);
    break;
    case '4':
      digitalWrite(_pins[5], HIGH);
      digitalWrite(_pins[6], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[2], HIGH);
    break;
    case '5':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[5], HIGH);
      digitalWrite(_pins[6], HIGH);
      digitalWrite(_pins[2], HIGH);
      digitalWrite(_pins[3], HIGH);
    break;
    case '6':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[2], HIGH);
      digitalWrite(_pins[3], HIGH);
      digitalWrite(_pins[4], HIGH);
      digitalWrite(_pins[5], HIGH);
      digitalWrite(_pins[6], HIGH);
    break;
    case '7':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[2], HIGH);
    break;
    case '8':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[2], HIGH);
      digitalWrite(_pins[3], HIGH);
      digitalWrite(_pins[4], HIGH);
      digitalWrite(_pins[5], HIGH);
      digitalWrite(_pins[6], HIGH);
    break;
    case '9':
      digitalWrite(_pins[0], HIGH);
      digitalWrite(_pins[1], HIGH);
      digitalWrite(_pins[2], HIGH);
      digitalWrite(_pins[5], HIGH);
      digitalWrite(_pins[6], HIGH);
    break;
  }
}


void Simple7Segments::clearAll()
{
  for (_count = 0; _count < QUANTITY_PINS; _count++)
  {
    digitalWrite(_pins[_count], LOW);
  }
}


void Simple7Segments::showAll()
{
  for (_count = 0; _count < QUANTITY_PINS; _count++)
  {
    digitalWrite(_pins[_count], HIGH);
  }
}


SevenSegmentsExample.pde
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
/**
 * Simple seven segments LED display
 *
 *
 */


#include "Simple7Segments.h"


#define LED_FINISH 12
#define DELAY 500


unsigned int count = 0;


// Define variable display.
// The numbers are the pins of the display
Simple7Segments display(2, 3, 4, 5, 6, 7, 8, 9);


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


void loop()
{
  char* buffer;
  itoa(count, buffer, 10);
  display.showNumber(buffer[0]);
  delay(DELAY);
  if (++count == 10)
  {
    count = 0;
    finish();
  }
}


void finish()
{
  digitalWrite(LED_FINISH, HIGH);
  delay(50);
  digitalWrite(LED_FINISH, LOW);
  delay(50);
  digitalWrite(LED_FINISH, HIGH);
  delay(50);
  digitalWrite(LED_FINISH, LOW);
}

Análise:

Linha 17) Cria uma instância da classe Simple7Segments passando no construtor os pinos correspondentes as posições no display.

Linha 27) Converte o valor da variável contadora (count) para char* (“String”).

Linha 28) Chama o método showNumber da instância display passando o número a exibir.

Linha 37) Método chamado quando uma contagem de 0 à 9 chega ao fim (pisca o LED).
Faça o download do código fonte completo aqui.

4.11) Controlando Led RGB com Arduino e Processing



Vamos a um exemplo de uso da Arduino onde controlo um Led RGB de quatro terminais através da porta serial.
Para enviar as cores através da serial usaremos processing.
Para combinar as cores de um Led RGB é necessário variar a tensão em cada terminal, e para isso a Arduino conta com 6 pinos PWM (Pulse Width Modulation, Modulação por largura de pulso), somente 3 são necessários, pois o quarto terminal deve ser conectado a GND (terra).

No exemplo conectamos os pinos da seguinte forma:
  • Terminal Vermelho no pino 9 (utilizando resistência de 150 Ohm)
  • Terminal Azul no pino 10        (utilizando resistência de 90 Ohm)
  • Terminal Verde no pino 11     (utilizando resistência de 90 Ohm)
  • Terminal terra no pino GND
Obs.: Como não tinha em mãos os resistores liguei os terminais diretamente aos pinos da arduino, mas é importante ressaltar que isso pode danificar o seu led e com certeza reduzir o seu tempo de vida útil.

RGB Led - Arduino + Processing from Bruno Soares on Vimeo.


Espesificação do Led usado:
  • Diâmetro: 5mm.
  • Bulbo: transparente.
  • Intensidade Luminosa: 8000 mcd.
  • Tensão: vermelho = 1.9 ~ 2.4v; verde e azul = 3.2 ~ 3.6v.
  • Corrente: 20mA.
  • Ângulo: 20 ~ 25º.
  • 5mm rgb led color especification
Vamos ao código utilizado na arduino:
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
/**
 * Controller LED RGB
 */

#define START_COLOR_CHAR '^'
#define END_COLOR_CHAR '$'
#define COLOR_SIZE 8
#define PIN_RED 9
#define PIN_GREEN 11
#define PIN_BLUE 10

char serialMessage[COLOR_SIZE];
unsigned int readChar;
unsigned int count;
unsigned long color;
unsigned int r;
unsigned int g;
unsigned int b;
boolean readingSerial;

void setup() {
  Serial.begin(9600);
  readingSerial = false;
}

void loop() {

  if (Serial.available() > 0 && !readingSerial) {
    if (Serial.read() == START_COLOR_CHAR) {
      serialReadColor();
    }
  }
}

void serialReadColor() {
  readingSerial = true;
  count = 0;
 
  iniReading:
  if (Serial.available() > 0) {
    readChar = Serial.read();
    if (readChar == END_COLOR_CHAR || count == COLOR_SIZE) {
      goto endReading;
    } else {
      serialMessage[count++] = readChar;
      goto iniReading;
    }
  }
  goto iniReading;
 
  endReading:
  readingSerial = false;
  serialMessage[count] = '\0';
 
  setColor(serialMessage);
}

void setColor(char* value)
{
  // Convert Char* to Long
  color = atol(value);
 
  // Extract RGB
  r = color >> 16 & 0xFF;
  g = color >>  8 & 0xFF;
  b = color >>  0 & 0xFF;
 
  // Send values to analog pins
  analogWrite(PIN_RED, r);
  analogWrite(PIN_GREEN, g);
  analogWrite(PIN_BLUE, b);
}


Linha 25) Iniciamos a conexão com a porta serial na velocidade 9600.
Linha 30) Verifica se existe mensagem na porta serial.
Linha 32) Chama o método serialReadColor para iniciar a leitura da serial.
Linha 57) Envia o texto lido entre os caracteres ^ e $ para o método setColor.
Linha 63) Converte o valor obtido para Long.
Linha 66 à 68) Extrai a quantidade de Red, Green e Blue da cor.
Linha 71 à 73) Envia a tensão para os pinos correspondêntes a cada cor.


Conclusão: A Arduino está programada para receber a cor em formato numérico entre dois caracteres que identificam o inicio e o fim da cor (^ para o inicio e $ para o fim). Sendo assim se enviarmos ^16711680$ o LED ficaria vermelho, pois o número 16711680 é o correspondente á 0xFF0000 (hexadecimal).

Agora o código do Processing:
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
/**
 * Controller LED RGB
 */

import processing.serial.*;

Serial port;

void setup() {
  size(100, 150);
  noStroke();
 
  // Background
  colorMode(HSB, 100);
  for (int i = 0; i < 100; i++) {
    for (int j = 0; j < 100; j++) {
      stroke(i, j, 100);
      point(i, j);
    }
  }
 
  // Select port
  println(Serial.list());
  port = new Serial(this, Serial.list()[1], 9600);
}

void draw() {
  // Only to enable the method mouseDragged
}

void mouseClicked() {
  processColor();
}

void mouseDragged() {
  processColor();
}

void processColor() {
  color c = get(mouseX, mouseY);
  noStroke();
  fill(c);
  rect(0, 100, 100, 50);
  sendColorToSerial(c);
}

void sendColorToSerial(color colour) {
  // Get HEX
  String hexColor = hex(colour, 6);
 
  // Convert HEC to Number
  long numColor = unhex(hexColor);
 
  // Send color number to serial port
  port.write("^" + numColor + "$");
}

A responsabilidade do Processing é se comunicar com a Arduino via porta serial e enviar as cores, pois com o processing podemos criar um aplicativo onde fica facíl selecionar a cor desejada.
Na linha 50 (método sendColorToSerial), o processing processa o objeto Color, obtendo o seu Hexa, transformando em um número do tipo long, concatenando esse número com os caracteres ^ e $, e finalmente enviando este dado formatado para a porta serial para a Arduino fazer o que está a sua responsabilidade.

Futuramente irei fazer um post somente sobre Processing e suas aplicações específicas e gerais...


4.10) Hello World com LCD + Arduino

LiquidCrystal - "Hello World!"

Tutorial Famoso Hello World compativel com Hitachi HD44780 driver.
output of the sketch on a 2x16 LCD
 
Esse LCD tem uma interface paralela, ou seja, você pode fazer diversos tipos de comandos/telas/caracteres... tudo pelo microcontrolador.

Hardware Necessário:

  • Arduino
  • Tela LCD (compativel com Hitachi HD44780 driver)
  • Potenciômetro 10k
  • ProtoBoard
  • Fios de Conexão

Circuito:

  • Pino LCD RS   digital 12
  • Pino LCD no pino digital 11
  • Pino LCD D4 no pino digital 5
  • Pino LCD D5 no pino digital 4
  • Pino LCD D6 no pinodigital 3
  • Pino LCD D7 no pino digital 2
Adicione o pot de 10K no +5V e GND, com a saída para o LCD no pino VO (pino3).
Como na Imagem Abaixo:


 
image developed using Fritzing. For more circuit examples, see the Fritzing project page
 

Antes de Codear aí....

Preste atenção que você terá de incluir #include <LiquidCrystal.h>
 pois é a bibioteca do LCD, definir os pinos de saida e entrada de dados ... aí sim joga sua Mensagem pra ele...
posteriormente vou colocar uns esquemas legais de ficar indo e voltando, piscar...menus com interatividade...
Se você ja Viu os outros tutoriais ja deve saber... de uma olhada em pisca LED, nos Projetos Simples, você coloca comando delay(1000) manda 
  lcd.print(" ") ou seja nada, depois seu texto denovo... com a VOID LOOP dai ele vai piscar seu texto de 1 em 1 segundo...

Código:

/*
  LiquidCrystal Library - Hello World
 

 Library originally added 18 Apr 2008
 by David A. Mellis
 library modified 5 Jul 2009
 by Limor Fried (http://www.ladyada.net)
 example added 9 Jul 2009
 by Tom Igoe
 modified 22 Nov 2010
 by Tom Igoe

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/LiquidCrystal
 */


// include the library code:

#include <LiquidCrystal.h>


// initialize the library with the numbers of the interface pins

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void
setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("hello, world!");
}


void
loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  // print the number of seconds since reset:
  lcd.print(millis()/1000);

}

Esse talvez pisca, como ainda não tenho arduino não testei , mas pelo meu pouco conhecimento acho que funciona, sei que compilou e não deu erros,  pelo menos testar eu sei que não daria problema nenhum então testem e me avisem...

/*
  LiquidCrystal Library - Hello World
 
Author: Marcelo Boeira

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/LiquidCrystal
 */

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  // print the number of seconds since reset:
  lcd.print(millis()/1000);
  // Print a message to the LCD.
  lcd.print("hello, world!");
  delay(1000);
  // Print empty message
  lcd.print("           ");
  delay(1000);
}




Conteúdo do Site Arduino.cc
Veja Mais em: http://arduino.cc/en/Tutorial/LiquidCrystal
Traduzido bem Por Cima...
Desculpem os erros, ta mais no sentido da tradução...

LCD Gráfico do NOKIA 3310 Direto Pela Serial

Eu encontrei este circuito muito simples e interessante. É realmente fácil controlar o LCD gráfico do Nokia 3310 usando um cabo simples e algum software no PC.A porta paralela do computador se conecta ao LCD através do seguinte circuito:


The image “http://www2.eletronica.org/hack-s-dicas/richdocument.2006-12-09.0677997135/lpt_to_nokia3310.png” cannot be displayed, because it contains errors.

















o display gráfico precisa de uma tensão na fonte de 3.3V, enquanto a porta paralela fornece aproximadamente 4.5 - 5V. É por isso que os diodos em série são usados, para reduzir a tensão pela fórmula: 4.5V - 0.7V - 0.7V = 3.1V.
Qualquer dúvida clique aqui e va para parte de diodos para revisar...


A pinagem do LCD Nokia 3310 é a seguinte:


The image “http://www2.eletronica.org/hack-s-dicas/richdocument.2006-12-09.0677997135/lcd_pins.jpg” cannot be displayed, because it contains errors.

A display gráfico utiliza o controlador PCD8544. A especificação deste pode ser baixada aqui: PCD8544.pdf  
 
Como você observou, os pinos de dados da porta paralela são usados para a transferência de dados e alimentação do LCD.



The image “http://www2.eletronica.org/hack-s-dicas/richdocument.2006-12-09.0677997135/port_data_pins.jpg” cannot be displayed, because it contains errors.

Quando o hardware estiver pronto, é hora de imprimir algumas imagens no LCD. Para isto baixe programa de controle (o fonte em pascal também está incluído).  O software é escrito para controlar diretamente os pinos no DOS ou Windows 98.
Se você está usando Windows 2000 ou XP você precisa ler isso.

Eu copiei uma das soluções aqui: baixe o programa PortTalk, descompacte e separe em alguma pasta. Então copie allowio.exe para o diretório onde está o programa que você quer rodar. Então crie um atalho para o seu programa compilado, por exemplo, LCD.exe. Então abra as propriedades do atalho e na linha alvo faça as seguintes alterações:

Ao invés de

D:/project/LCD.exe
troque para

D:/project/allowio.exe D:/project/LCD.exe /a
Lembre-se que você precisa ter privilégios de administrador no computador. É um truque feio mais funciona.


Tudo funcionando, execute o programa e desenhe com o botão esquerdo. O botão direito apaga:

The image “http://www2.eletronica.org/hack-s-dicas/richdocument.2006-12-09.0677997135/lcd_in_progress.jpg” cannot be displayed, because it contains errors.



Boa sorte !


Posteriormente (mais precisamente quando chegar meu LCD Nokia e meu Arduino) vou mostrar mais tutoriais com LCD Nokia 3310 e LCD Sheilds também...

Liberando Porta Paralela ou Serial



As versões XP, NT e 2000 dos sistemas operacionais da Microsoft implementam uma política de segurança que impede o usuário de trabalhar diretamente com a porta paralela. Neste breve texto, mostraremos como liberar o acesso para que nossos projetos eletrônicos funcionem devidamente.

Seria interessante se você pretende seguir alguns dos tutoriais aqui dispostos ...


A solução para esta situação dar-se através de peças de software. Bibliotecas diferentes devem ser utilizadas na hora de implementar as rotinas para que não haja problemas de segurança.
No entanto, vários softwares já estão prontos e não possuem versões desenhadas especificamente para suprir estas necessidades. É aí que entra um outro programa, o UserPort, desenvolvido por Tomas Franzon. A documentação completa do UserPort, em PDF e inglês, pode ser vista aqui.
Para facilitar, aqui estão os passos rápidos para que os seus programas voltem a funcionar:



  • Pegue o arquivo UserPort.zip clicando aqui.

  • Descompacte o arquivo em um diretório (pasta) escolhido por você.

  • Copie o arquivo UserPort.sys para o diretório c:/windows/system32/drivers (ou c:/winnt/system32/drivers para o Windows NT).

  • Execute o programa UserPort.exe.

  • Mude os endereços para 0x378-0x37A, clicando em "ADD". 

  • Remova os outros endereços com o botão "Remove". 

  •  Clique em "Start". 



  • Com estes passos, o seu sistema operacional estará "desbloqueado" para acesso direto a porta paralela. O procedimento só é necessário uma única vez. Caso deseje voltar a condição anterior, basta iniciar novamente o programa e clicar em "STOP".

  • 7.1) Instrumentos Básicos

    Introdução
    O objetivo deste texto é explicar, resumidamente, o funcionamentos dos principais instrumentos de medição que necessitamos no primeiro ano de um curso técnico de eletrônica ou até mesmo nas aulas de laboratório de um curso de engenharia elétrica. Este texto também é útil a amantes da eletrônica que estão iniciando montagens de pequenos projetos.
    Inicialmente, irei explicar o que é cada instrumento de medição, para que serve e como deve ser utilizado, aproveitarei também para dar dicas em relação aos principais erros cometidos e o que não fazer para manter seus equipamentos e circuitos em perfeito estado de conservação.
    No fim, há uma pequena discussão sobre qual a real necessidade de cada um ao adquirir um destes instrumentos de medição.
    Analógicos x Digitais
    Normalmente, quando falamos de instrumentos de medição, sempre há a menção: "é analógico ou digital"? Normalmente, estamos nos referindo a forma com que a medição - e consequente indicação - é feita.
    Os modelos analógicos tem como vantagem uma boa fidelidade de medição, mesmo sob presença de harmônicas e outras interferências no circuito que se deseja medir. Já os digitais possuem a vantagem de uma melhor visualização, principalmente os que utilizam LCD (liquid cristal display) com back light (luz de fundo).
    Figura 1. Amperimetro Analógico Figura 2. Voltímetro Digital


    Recomendações Gerais
    Antes de fazer suas medições, estude bem tanto o circuito quanto o instrumento que você irá utilizar. Muitas vezes, utilizamos o instrumento certo, porém configurado/parametrizado de forma incorreta e acabamos por danificar tanto o instrumento de medição quanto o circuito a ser medido.
    Lembre-se também que uma corrente de cerca de 100mA passando pelo seu corpo é o suficiente para o comprometimento da sua vida. Na dúvida, não faça a medição.
    Amperímetros
    Para que servem?
    Um amperímetro, como o próprio nome sugere, serve para medirmos ampéres, isto é, corrente. Existem amperímetros para medição em corrente contínua (C.C., DC) e para corrente alternada (C.A., AC).
    Como devo utilizá-lo?
    Um amperímetro sempre deve ser conectado em série ao sistema, como é ilustrado abaixo.
    Figura 3. Esquema de ligação de um amperímetro
    A resistência interna do amperímetro é extremamente pequena, o que significa que ele não interfere na resistência equivalente do circuito, indicando uma corrente próxima a aquela que realmente existe no circuito. Quando estamos trabalhando em um circuito de corrente alternada, não devemos nos preocupar com a polaridade do amperimetro, isto é, tanto faz qual cabo conectaremos em cada parte do circuito. No entanto, ao trabalharmos em corrente contínua, devemos nos ater ao sentido da corrente. A corrente sempre deve entrar no amperímetro pelo seu polo positivo (+, normalmente indicado pela cor vermelha) e sair pelo seu pólo negativo (-, normalmente indicado pela cor preta).
    Dicas
    A maioria dos amperímetros possui fusíveis de proteção interna, para o caso da corrente que for passar pelo amperímetro ser maior do que a sua capacidade. Eventualmente, ao utilizarmos o amperimetro de forma incorreta, esses dispositivos de proteção atuarão e terão de ser substituídos. Por isso, mantenha um bom estoque deles em sua bancada ;)
    Certos amperímetros (principalmente os inclusos em multímetros), não possuem proteção para certas escalas, normalmente estas são identificadas como unfused (sem fusível, na tradução). Nestes casos, é uma idéia se conectar um fusível em série com uma corrente nominal compatível com a escala que estamos utilizando.
    Como foi dito no item "Como devo utilizá-lo?", é necessário conectar sempre o amperímetro em série ao circuito. Em certas situações, veremos que isto não é possível, como no circuito de nossa casa. Suponhamos que queremos medir a corrente de uma das fases que alimentam o circuito interno de uma residência. Infelizmente, não é possível "abrirmos" o circuito sem que haja o desligamento do mesmo. Neste tipo de situação, utilizamos o alicate amperímetro, que é um sensor de corrente que é colocado em volta do cabo que se deseja medir, e, através de um sensor com base no efeito hall, é feita a medição da corrente da linha, tanto contínua quanto alternada.
    Figura 4. Alicate Amperímetro


    Principais Erros
    O principal erro ao se utilizar um amperímetro é efetuar a medição em paralelo, não em série. O resultado disto é um curto-circuito, evidenciado pela carbonização de alguns pontos e a possível queima da proteção do equipamento ou mesmo de seu fusível. Vamos entender melhor o que acontece ao conectarmos o amperímetro em paralelo a um circuito F+N, com 127Vc.a. nominais.
    A resistência interna do amperímetro, como dito anteriormente, é extremamente baixa. Como exemplo, utilizaremos o equipamento "DG 48 Alternado - Entrada 5Ac.a.", de fabricação da KRON Instrumentos Elétricos, tal equipamento é um indicador de painel para corrente alternada de até 5Ac.a.. Conforme o catálogo técnico do fabricante, a resistência interna deste amperímetro de painel é de 0,02 ohms. Pela lei de ohm, teremos uma tensão de 127Vc.a. com uma resistência de apenas 0,02 ohms, o que nos daria absurdos 6350Ac.a. passando pelo amperímetro. Obviamente dispositivos de segurança irão atuar, seja m eles fusíveis, dispositivos internos do instrumento ou até mesmo o disjuntor do quadro da instalação em questão.
    Na melhor das hipóteses, teremos apenas de substituir o fusível do equipamento. Na pior, podemos danificar não só o equipamento, mas também o circuito que estamos medindo.
    Voltímetros
    Para que servem?
    Voltímetros, como o próprio também sugere, medem VOLTS, isto é, diferença de potencial, ou tensão, como preferir. Um voltímetro também pode ser para corrente alternada ou corrente contínua.
    Como devo utiizá-lo?
    Um voltímetro, ao contrário do amperímetro, possui alta resistência interna, para que pouca corrente circule por ele e não ocorra alteração na resistência equivalente do circuito a ser medido. A sua conexão a um circuito é ilustrada abaixo, onde estamos medindo a queda de tensão existente em cima da lâmpada de 120 ohms.
    Figura 5. Esquema de ligação de um voltímetro
    Dicas
    Assim como o amperímetro, não existe polaridade para o voltímetro quando estamos trabalhando em corrente alternada. No entanto, ao trabalharmos com corrente contínua, passamos a ter de respeitar a polaridade.
    Principais erros
    Ao contrário do amperímetro, onde efetuar a conexão de forma incorreta, pode ocasionar danos ao circuito e ao instrumento, conectar um voltímetro em série não acarreta nenhum tipo de dano ao instrumento ou ao circuito que está se medindo. Explica-se: conectar uma resistência altíssima em série faz com que a corrente de todo o circuito diminua, ocasionando, muito provavelmente uma interrupção de seu funcionamento. No entanto, não existe possibilidade de queima.
    Multímetro
    Um multímetro, como o nome indica, engloba a medição de diversas grandezas em um só aparelho.
    Figura 6. Multímetro
    O que um multímetro pode ter?
    A tabela abaixo indica os principais tipos de medida que um multímetro engloba:
    Grandeza Unidade Comentário
    Tensão Vc.a., Vc.c. Indispensável. A maioria dos multímetros trabalha com tensões de até 1000V. Para circuitos de baixa tensão, é mais do que o suficiente.
    Corrente Ac.a.,, Ac.c. Indispensável.. Dê preferência aos que tem fusível com fácil acesso.
    Ohmímetro Ohms Indispensável. Mede resistência e, em muitos casos, continuidade de dois pontos. Lembre-se que esta escala só deve ser utilizada com o circuito desenergizado. Dê preferência aos que possuem teste de continuidade e para diodo com "bip" (aviso sonoro).
    Ganho de Transistor (hFE) Útil para verificação de transistores. Embora não seja preciso, é util para se determinar se o transistor está ou não funcionando.
    Capacímetro F Útil para medição de capacitores. Lembre-se de desenergizar os capacitores antes de utilizá-lo.
    Indutímetro H Útil para medição de indutores. Lembre-se de desenergizar os indutores antes de utilizá-lo.
    Frequencímetro Hz Útil para medição da frequencia do sinal alternado. Pode-se obter esta frequencia tanto através da corrente como da tensão.
    Wattímetro W Útil para medição da potência ativa (W) e reativa (Var). Normalmente se utiliza essas opções em testes de motores de corrente alternada, onde se deseja medir o rendimento do mesmo. É necessário tanto sinais de tensão quanto de corrente.
    Varímetro Var
    Cosfímetro   Mede o fator de potência, isto é, a defasagem entre a tensão e a corrente.É necessário tanto sinais de tensão quanto de corrente. Sua aplicação é semelhante a dos wattímetros e varímetros.


    Como escolher?
    Existem diversos tipos de multímetros no mercado, de R$ 20,00 a até, acredite, R$ 20.000,00. Antes de escolher o seu, vale a pena ponderar: você pretende fazer um uso profissional do mesmo ou é apenas um praticamente da eletrônica amadora? Caso sua opção seja a primeira, vale a pena investir em um modelo completo, com medição true rms (para formas de ondas distorcidas), saída serial para micro (para facilitar levantamentos de dados), etc.
    Caso sua opção seja apenas o amadorismo, um modelo com escalas de tensão, corrente e resistência é mais do que o suficiente.
    Fatores que são relevantes na compra são: classe de isolação do instrumento, certificação do fabricante, garantia do produto, resolução (como os dados são indicados) e incerteza (variação na leitura do instrumento).
    Onde comprar?
    Se você é de São Paulo, um bom local para adquirir multímetros é a Santa Efigênia, famoso local do centro de São Paulo que reune as melhores lojas de componentes e equipamentos eletrônicos. O acesso mais fácil a Santa Efigência é pelos Metrô Luz ou São Bento, da linha azul.
    No entanto, se você morar em outras cidades, é possível encontrar multímetros em casas de elétrica ou através do site MercadoLivre.
    Dicas
    • Medição: Escolha a escala adequada antes de conectar o multímetro ao circuito. Se, por exemplo, você vai medir uma bateria de 9V e tem disponíveis as escalas de 200mVcc, 2Vcc, 20Vcc e 200Vcc, utilize a de 20Vcc para ter uma melhor precisão de sua medição.
    • Pontas de prova: O ideal sao as de invólucro de borracha (altamente isoladas) e com ponta fina, para evitar curto-circuitos. As pontas de prova devem fazer um ângulo de 90º com o que se deseja medir.
      Dê preferência a pontas de prova onde se possa encaixar garras jacaré, úteis quando se deseja, por exemplo, fazer medição de diversos pontos ao terra do circuito.

    6.3) Capacitores

    Capacitores

    Dispositivo ou componente eletrônico, cuja função é armazenar cargas em forma de energia elétrica.
    Consiste de dois condutores, chamados de armadura, os quais são colocados lado-a-lado e isolados por um material isolante chamado de dielétrico.
    Este componente também é conhecido como condensador e é representado pelo símbolo abaixo.



    Seus valores são expressos em Farad ( F ).

    O Farad é uma unidade muito grande, por esse motivo os capacitores são representados pelos seus submúltiplos.



    Alguns capacitores apresentam uma codificação ou números, um pouco estranha para os técnicos experientes, e muito difícil de compreender, para o técnico novato.

    Observe o desenho abaixo.



    O valor do capacitor, "B", é de 3300 pF (Picofarad = x10-12 F) ou 3,3 nF ( Nanofarad = x10-9 F ) ou 0,033 µF ( Microfarad = x 10-6 F ). No capacitor "A" , devemos acrescentar mais 4 zeros após ao 1ª e 2ª algarismo. O valor do capacitor, que se lê 104, é de 100000 pF ou 100 nF ou 0,1µ F.

    Capacitores usando letras em seus valores.

    O desenho a baixo, mostra capacitores que tem os seus valores, impressos em nanofarad (nF) = 10-9F. Quando aparece no capacitor uma letra "n" minúscula, como um dos tipos apresentados a baixo por exemplo: 3n3, significa que este capacitor é de 3,3nF. No exemplo, o "n" minúsculo é colocado ao meio dos números, apenas para economizar uma vírgula e evitar erro de interpretação de seu valor.


    Multiplicando-se 3,3 por x10-9 = ( 0,000.000.001 ), teremos 0,000.000.003.3 F. Para se transformar este valor em microfarad, devemos dividir por 10-6 = ( 0,000.001 ), que será igual a 0,0033µF Para voltarmos ao valor em nF , devemos pegar 0,000.000.003.3F e dividir por 10-9 = ( 0,000.000.001 ), o resultado é 3,3nF ou 3n3F.
    Para transformar em picofarad, pegamos 0,000.000.003.3F e dividimos por x10-12, resultando 3300pF. Alguns fabricantes fazem capacitores com formatos e valores impressos como os apresentados abaixo. O nosso exemplo, de 3300pF, é o primeiro da fila.



    Note nos capacitores seguintes, envolvidos com um círculo azul, o aparecimento de uma letra maiúscula ao lado dos números. Esta letra refere-se a tolerância do capacitor, ou seja, o quanto que o capacitor pode variar de seu valor em uma temperatura padrão de 25° C. A letra "J" significa que este capacitor pode variar até 5% de seu valor, a letra "K" = 10% ou "M" = 20%. Segue na tabela abaixo, os códigos de tolerâncias de capacitância.



    Agora, um pouco sobre coeficiente de temperatura "TC", que define a variação da capacitância dentro de uma determinada faixa de temperatura. O "TC" é normalmente expresso em % ou ppm/°C ( partes por milhão / °C ). É usado uma seqüência de letras ou letras e números para representar os coeficientes. Observe o desenho abaixo.



    Os capacitores a cima são de coeficiente de temperatura linear e definido, com alta estabilidade de capacitância e perdas mínimas, sendo recomendados para aplicação em circuitos ressonantes, filtros, compensação de temperatura e acoplamento e filtragem em circuitos de RF.

    Na tabela abaixo, estão mais alguns coeficientes de temperatura e as tolerâncias que são muito utilizadas por diversos fabricantes de capacitores.



    Outra forma de representar coeficientes de temperatura é mostrado abaixo. É usada em capacitores que se caracterizam pela alta capacitância por unidade de volume (dimensões reduzidas) devido a alta constante dielétrica sendo recomendados para aplicação em desacoplamentos, acoplamentos e supressão de interferências em baixas tensões.



    Os coeficientes são também representados com seqüências de letras e números como por exemplo : X7R, Y5F e Z5U. Para um capacitor Z5U, a faixa de operação é de +10°C que significa "Temperatura Mínima" e +85°C que significa "Temperatura Máxima" e uma variação de "Máxima de capacitância" , dentro desses limites de temperatura, que não ultrapassa -56%, +22%. Veja as três tabelas abaixo para compreender este exemplo e entender outros coeficientes.



    Capacitores de Cerâmica Multicamada


    Capacitores de Poliester Metalizado usando código de cores.
    A tabela a baixo, mostra como interpretar o código de cores dos capacitores abaixo. No capacitor "A" , as 3 primeiras cores são, laranja, laranja e laranja, correspondem a 33000, equivalendo a 3,3 nF. A cor branca, logo adiante, é referente a 10% de tolerância. E o vermelho, representa a tensão, que é de 250 volts.






    Carga e Descarga:


    E muito mais aplicações, desse conteúdo acima deve entender que capacitor armazêna energia em um tempo de carga Calculado em:


    T = 5RC


    Sendo T: em Segundos
    R: Resistencia em Ohms
    C: Capacitância em FARAD's  (ou uF se R for em MOhms)

    Capacitores em Circuitos:


    O capacitor é regulado, calculado ao contrário da maioria dos outros componentes ...

    Série: Ele Divide sua capacitância com mesma fórmula dos resistores.

      1   =  1 + 1 + 1 +1
    Ceq    C1  C2  C3  CR


    Paralelo: Simplesmente se Soma a Capacitância.


    Uso de Capacitores:
    Retificação : Para diminuir e/ou estabilizar a perda de tensão na retificação.

    Motores: Ajuda na partida com carga de motores dando primeiro PULSO para embalo.


    Timers: Com sua "Habilidade" de carregar e Descarregar em periodos de tempo ele se torna de extrema importância em circutos timers.(temporizadores)



    Depois de carregado ele dispara essa carga no circuito,
    Fonte:http://www.equipetecnica.com.br/capacitor/capacitores.htm