Você Vai precisar de:
10 Leds
10 Transistores BC548
01 Transitor BD 135
10 Resistores de 1k
01 Resistor de 47Ohms
01 Resistor (Depende a Tabela Abaixo)
01 Resistor de 10k
11 Resistores 470Ohms
11 Diodos 1N4148
01 Capacitor 22uF
01 Fonte 12v DC
01 Transformador 110/6V de Baixa Corrente...
Estou trabalhando em uma placa de circuito impresso com um esquema muito mais elaborado e preciso, esqueminha profissional mesmo, quando terminar posto aqui no blog o tutorial passo a passo.
Mostrando postagens com marcador B03iR4 Tutoriais. Mostrar todas as postagens
Mostrando postagens com marcador B03iR4 Tutoriais. Mostrar todas as postagens
Testando Entradas USB e Fazendo uma Luminária USB
Essas USB frontais não são ligadas diretas à placa mãe, são uma extensão da mesma, e são muito fáceis de serem invertidas. Quanto mais USB, mais fácil a chance de ter portas invertidas.
Você não conhece ninguém que perdeu um pen-drive com USB invertida? Então, prazer. Eu já tive um pen-drive perdido dessa maneira.
Então, vamos ao que interessa, como fazer um teste de USB??
Funcionamento: As portas USB funcionam com 4 fios mas só precisaremos de dois, um de +5V e o outro de 0V(terra). Quando invertida a porta os fios são trocados e por isso queimam os dispositivos. O Teste de USB se baseia nisso daí, em duas luzinhas(leds); Normal ou Invertido. Lembre: NÃO usaremos os fios VERDES nem BRANCO.
Sugestão:
Leia nosso material sobre LED, Resistores, e Associação de Resistores para este "tutorial".
Material Para os Testes USB:
2 Resistores de 390R: R$0,05 cada
2 Leds (Verde e Vermelho): R$0,15 cada
1 Cabo USB(qualquer cabo que tenha USB): R$4,00
1/5 Metro de cabo Termoretrátil: R$0,50
Solda, tesoura, ferro de solda, etc...
(obs: qualquer cabo usb serve)
Simulando: Usando o Proteus fiz uma simulação do circuito elétrico em duas posições, Normal e Invertida. Bem simples, mas se alguém não entender comenta aií que nós ajudamos.
Esquema no Proteus 7 |
1) Corte o cabo USB do tamanho que lhe for viável (eu deixei uns 8 dedos pra usar ele como lanterna também) e descasque os dois fios de dentro. Lembrando das cores dos fios: +5V e TERRA.
Cabo USB cortado |
Resistores e leds cortados |
Resistores soldados nos leds |
Leds com cabos termoretrátil |
8) Solde a perna MAIOR do led VERMELHO ao fio PRETO.
Obs: Lembre que você escolheu colocar o resistor em uma das duas pernas do led, logo, uma perna do led estará em um fio VERMELHO (ou PRETO) e a outra estará no resistor que por sua vez estará no fio PRETO (ou VERMELHO).
Feito isso, você deve estar com algo parecido com isso:
Se não quiser deixar os leds soltos, pode colocar umas espécia de invólucro para eles. No meu eu coloquei a capa de um plug do tipo banana e cola quente na ponta por questão de organização e proteção dos leds. Fica a gosto.
Se você tem medo de testar na USB então sugiro fazer um esquema na matriz de contatos (protoboard) antes de montar tudo:
Teste com um led | Teste com um led (sem flash) |
Você pode implementar o projeto usando LED's de Alto Brilho, que tem um pouco mais de corrente mas não afetam nada no caso deste circuito, talvez você tenha que alterar o resistor.
Tendo um resultado final parecido com algum destes,(idéia)...
Lembrando: Corrente Máx. do USB é 500mA, ou 0,5A então CALCULE antes de implementar o peojeto.
DICA:
Vfonte = 5v(USB);
Vled = Depende do seu LED; (COR)
Iled = Corrente do seu led, recomento 20/25 para os LED's Normais.
Medidor VU com Arduino
O medidor de VU é basicamente um medidor para o controle do sinal do som. Tentei achar o significado de VU na internet e nada, achei somente que vem de VI (Volume Indicator)
1x Cabo com entrada de audio e saida desemcapada(Um vai pro GND o outro pro Pino 0 do Arduino como veremos asseguir);
Pinos Digitais dos LED's(3 ao 12);
Pino de entrada de Som (0 Analógico);
Código Para Seu arduino:
Para este VU com Arduino Vamos precisar de:
1x Arduino Com 10 Saídas Digitas e 1 Analógica Disponiveis;
10x Leds(cores a sua escolha);
10x Resistores de 560Ω;1x Cabo com entrada de audio e saida desemcapada(Um vai pro GND o outro pro Pino 0 do Arduino como veremos asseguir);
Circuito:
Pino de entrada de Som (0 Analógico);
Código Para Seu arduino:
int led[10] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; // definindo pinagem dos LED's
int leftChannel = 0; //canal de entrada de som
int left, i;
void setup()
{
for (i = 0; i < 10; i++) //definindo as saídas digitais
pinMode(led[i], OUTPUT);
// Serial.begin(9600); //Iniciando comunicação Serial
}
void loop()
{
left = analogRead(leftChannel); // lendo o sinal do som
// Serial.println(left); // enviando para serial sinal do som
left = left / 50; // ajuste de sensibilidade
// Serial.println(left); // mostrar sinal modificado na serial
// left = 1500; //pulso para testar leds
// left = 0;
if (left == 0) //se volume = 0 todos LED's estão Off.
{
for(i = 0; i < 10; i++)
{
digitalWrite(led[i], LOW);
}
}
else
{
for (i = 0; i < left; i++) // ligando os led's com dependência do volume
{
digitalWrite(led[i], HIGH);
}
for(i = i; i < 10; i++) // desligando os leds após o volume abaixar
{
digitalWrite(led[i], LOW);
}
}
}
Projeto EscaPe! v1.1
Ontem a noite sem nada pra fazer comecei a trabalhar com novos caracteres para a LCD Shield e aprendi a criar caracteres especiais com este site você tem uma idéia de como eles vão ficar.
Criei alguns avatares,bonequinhos,símbolos e gostei, pensei então em fazer o bonequinho andar na tela com os comandos:
lcd.setCursor(x,y);
X=Valor de 0 a 15(no caso de LCD 16x2); - COLUNA
Y=Valor 0 ou 1 (Linha de cima ou de baixo) - LINHA
Recomendo quem quer entender o código por completo que leia o outro tutorial que fiz para o reconhecimento das teclas da shield lcd, pois irei usar o mesmo código para fazer com que vá para cima/baixo...
------------------------------------------
Nome do Jogo: EscaPe!
Versões:
- 1.0: (Bugs simples logo serão corrigidos);
1.1 (Implementado e corrigido 3 Bugs, ainda tem bastante bugs mas como estou sem muito tempo talvez demore a concertar todos - Qualque ajuda é bem vinda).
No Pack de Download estão todas as versões para você poder avaliar a evolução.
Totalmente OPEN SOURCE: Download do Código (coloquei assim porque é muito grande o código para largar aqui, +-350 linhas)
User como quiser.
Você pode acompanhar notícias do jogo pela label EscaPe! aguardem muitas novidades até o fim do mês.
Reconhecendo Teclas com Shield LCD
Fiz um Exemplo rápido de como "Lêr" as teclas da shield LCD, é bem simples, todos os botões são ligados na mesma entrada Analógica, a 0, por isso para diferenciar as teclas são usados resistores, fazendo com que valores diferentes sejam interpretados pelo arduino.
Não sei se é o caso de todas mas na minha as teclas são organizadas dessa forma:
Fotos em Breve...
------------------------------------------------------------------
Tecla - Valor:
Cima - 146
Baixo - 334
Direita - 0
Esquerda - 511
Selecionar - 745
------------------------
Qualquer coisa se não for este valor, ou quiser saber como ligar faça assim:
1) Ache o Datasheet da Sua Shield e confira qual pino Analógico dos botões.
2) Coloque este código em seu arduino substituindo o indicado pelas suas informações.
3) Anote o valor de cada tecla e faça um "coeficiente de cagaço" ou seja a margem de erro, de uns 50 para mais e para menos, mas cuide para que este 50 para mais ou para menos não entre no valor de outra tecla.
#include <LiquidCrystal.h>5) Aqui está o código com os valores da minha Shield, ele lê a tecla e mostra qual é na tela.
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //use a pinagem de seu arduino
void setup(){
lcd.begin(16,2);
Serial.begin(9600);
}
void loop(){
delay(1000);
lcd.clear();
int tecla_valor = analogRead(0);// 0 é o pino da sua entrada analógica
lcd.print(tecla_valor);//tecla_valor armazena o valor lido e joga pra tela LCD.
}
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //use a pinagem de seu arduino
void setup(){
lcd.begin(16,2);
Serial.begin(9600);
}
void loop(){
delay(90);
lcd.clear();
int tecla_valor = analogRead(0);
if (tecla_valor == 0)
{
lcd.print("Direita 0");
delay(100);
}
if ((tecla_valor >= 120) & (tecla_valor <= 146))
{
lcd.print("Cima 146");
delay(100);
}
if ((tecla_valor >= 300) & (tecla_valor <= 350))
{
lcd.print("Baixo 334");
delay(100);
}
if ((tecla_valor >= 500) & (tecla_valor <= 530))
{
lcd.print("Esquerda 511");
delay(100);
}
if ((tecla_valor >= 700) & (tecla_valor <= 790))
{
lcd.print("Selecionar 745");
delay(100);
}
delay(50);
}
Como prometido criei um "menuzinho", percebam que está cheio de bugs ainda, quando você vai pra negativo e volta pra positivo ficam números errados na tela, e várias outras coisas, mas como estou ainda em fase de testes nesse projeto do Relógio vou desenvolver um menu para poder alterar a hora do relógio pelo sistema mesmo e não mais pelo source, então vou aos poucos mudando o código abaixo...
Se alguém conseguir avanços poste ai, OpenSource é isso!
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //use a pinagem de seu arduino
int up;
int down;
int nothing;
int right;
int left;
int enter;
int sel;
int x;
int y;
void setup() {
lcd.begin(16, 2);
lcd.write(0);
sel = 0;
x = 0;
y = 0;
up = 0;
down = 0;
right = 0;
left = 0;
enter = 0;
nothing = 0;
}
void loop(){
delay(100);
int tecla_valor = analogRead(0);
if (tecla_valor == 1023){
up = 0;
down = 0;
right = 0;
left = 0;
enter = 0;
nothing = 1;
}
if (tecla_valor == 0)
{
right = 1;
}
if ((tecla_valor >= 120) & (tecla_valor <= 146))
{
up = 1;
}
if ((tecla_valor >= 300) & (tecla_valor <= 350))
{
down = 1;
}
if ((tecla_valor >= 500) & (tecla_valor <= 530))
{
left = 1;
}
if ((tecla_valor >= 700) & (tecla_valor <= 790))
{
enter = 1;
}
delay(50);
lcd.setCursor(x,y);
if (down == 1){
sel = sel -1;
}
if (up == 1){
sel = sel + 1;
}
if (enter == 1) {
(x=x+1);
}
lcd.print(sel);
}
Mais um exemplo, mas esse com menus escritos, tem 3 menus mas pode expandir para mais menus e sub-menus....
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //use a pinagem de seu arduino
int up;
int down;
int nothing;
int right;
int left;
int enter;
int sel;
int x;
int y;
void setup() {
lcd.begin(16, 2);
lcd.write(0);
sel = 1;
x = 0;
y = 0;
up = 0;
down = 0;
right = 0;
left = 0;
enter = 0;
nothing = 0;
}
void loop(){
int tecla_valor = analogRead(0);
if (tecla_valor == 1023){
up = 0;
down = 0;
right = 0;
left = 0;
enter = 0;
nothing = 1;
}
if (tecla_valor == 0)
{
right = 1;
}
if ((tecla_valor >= 120) & (tecla_valor <= 146))
{
up = 1;
}
if ((tecla_valor >= 300) & (tecla_valor <= 350))
{
down = 1;
}
if ((tecla_valor >= 500) & (tecla_valor <= 530))
{
left = 1;
}
if ((tecla_valor >= 700) & (tecla_valor <= 790))
{
enter = 1;
}
delay(120);
if (right == 1){
sel++;
}
if (left == 1){
sel--;
}
if (sel<=1){
sel =1;
lcd.clear();
lcd.print(" MENU 1 >> ");
}
if (sel==2){
lcd.clear();
lcd.print(" < MENU 2 > ");
}
if (sel>=3){
sel=3;
lcd.clear();
lcd.print(" << MENU 3 ");
}
}
Meu Primeiro "Projeto" Com Arduino.(AtualizadO)
Acabei de pegar meu Arduino MEGA 1280, e comecei a brincar com led's...
Comprei junto uma Shield LCD e resolvi transportar um programa que eu havia criado pra PASCAL/Windows pra o arduino e mostrá-lo na LCD 16x2.
Veja como Ficou:
Este video é meio antigo, é da primeira versão que criei desse relógio geek...
Eu ja havia criado o algorítimo para o relógio em si, mas nada muito criativo, apenas uma implementação para "mostragem" correta da hora apartir de algumas combinações de números. Tinha feito em PASCAL e rodava perfeitamente no PC resolvi "portar" para C logo que comprei a Shield LCD, deu um pouco de trabalho mas ficou legal. Estou trabalhando agora com as teclas da Shield para o Ajuste de Hora entre outras peculiaridades.
Sugiro que ignorem nos códigos a parte de Temperatura, e também lhes informo que a contagem da hora atrasa muito depois de umas 4 horas de uso.
Estou pensando em colocar um RTC, não deve mudar drasticamente o Código.
-------------------------------------------------------------------------
Códigos Usados:
Inclui v1.3.3 que tem já ajuste de hora pela Shield.
mediafire.com/?d2dz22kaw177n99
-------------------------------------------------------------------------
Comprei junto uma Shield LCD e resolvi transportar um programa que eu havia criado pra PASCAL/Windows pra o arduino e mostrá-lo na LCD 16x2.
Veja como Ficou:
/// ATUALIZAÇÃO
Este video é meio antigo, é da primeira versão que criei desse relógio geek...
Eu ja havia criado o algorítimo para o relógio em si, mas nada muito criativo, apenas uma implementação para "mostragem" correta da hora apartir de algumas combinações de números. Tinha feito em PASCAL e rodava perfeitamente no PC resolvi "portar" para C logo que comprei a Shield LCD, deu um pouco de trabalho mas ficou legal. Estou trabalhando agora com as teclas da Shield para o Ajuste de Hora entre outras peculiaridades.
Sugiro que ignorem nos códigos a parte de Temperatura, e também lhes informo que a contagem da hora atrasa muito depois de umas 4 horas de uso.
Estou pensando em colocar um RTC, não deve mudar drasticamente o Código.
-------------------------------------------------------------------------
Códigos Usados:
Inclui v1.3.3 que tem já ajuste de hora pela Shield.
mediafire.com/?d2dz22kaw177n99
-------------------------------------------------------------------------
Um monitor de batimentos cardíacos para o ARDUINO
Parte 1: “Vendo” os pulsos
Introdução
A Eletrônica nos permite criar aparelhos que são de fato extensões de nossos sentidos, como aqueles que são capazes de captar certos sinais fisiológicos que normalmente somos incapazes de sentí-los. Uma vez captados por algum tipo de sensor esses sinais podem ser amplificados e digitalizados, depois podem ser alterados e até mesmo controlados com alguma forma de feedback. Um desses sinais fisiológicos é o número de batimentos do nosso coração. Emoções fortes como raiva e excitação causam um aumento da taxa de batimentos do coração humano. Outras emoções como tristeza e pesar fazem essa taxa diminuir. Meditação, contemplação e outros estados mentais tambem mexem com essa taxa. Com a ajuda do Arduino e um amplificador de alto ganho com sensor ótico podemos monitorar nossa taxa de batimentos cardíacos na tela do nosso PC. Fica fácil assim montar um instrumento que pode ser usado para experiências com controle de stress, respiração, relaxamento e biofeedback.Hardware
Nosso protótipo foi montado numa pequena placa perfurada de 3,5 x 5,5 cm para ser encaixada sobre o Arduino como um shield. Veja a figura 1. Os componentes são interligados com pequenos fios no lado da solda da placa.
Como fonte de luz para o sensor usamos um LED vermelho comum de 3 mm. O experimentador deve posicionar o lado oposto à unha de seu dedo indicador sobre o LDR, e a dobra entre a ponta e o meio do dedo sobre o LED. A luz que é emitida pelo LED atravessa a pele da dobra e é refletida pelo osso sobre uma pequena concentração de artérias bem em cima do LDR. O volume de sangue nesse grupo de artérias pulsa em sintonia com as contrações do músculo cardíaco. Essa informação vai modular a resistência do LDR.
No circuito do monitor o resistor R1 limita a corrente direta atraves de LED1 em cerca de 20 mA. O LDR e o resistor R2 formam um circuito divisor de tensão cuja saída pulsante será função da resistência do LDR que é função da luz refletida pelo dedo do experimentador.
Sugerimos ao leitor primeiro montar o conjunto fonte de luz/sensor. Para o nosso protótipo montamos esse conjunto em uma pequena caixa plástica de 3x4x1 cm, como na figura 2. Nessa caixa foi montada a pequena placa perfurada com o LED vermelho de 3 mm e seu resistor de 270 ohms e o LDR e seu resistor de 39 Kohms.
Lista de componentes | |
R1 e R10 | Resistor 270 ohms x 1/8W |
R2 | Resistor 39K ohms x 1/8W |
R3 e R6 | Resistor 68K ohms x 1/8W |
R4 | Resistor 8K2 ohms x 1/8W |
R5 | Resistor 1M ohms x 1/8W |
R7 | Resistor 560K ohms x 1/8W |
R8 | Resistor 1K ohms x 1/8W |
R9 | Resistor 1K8 ohms x 1/8W |
P1 | Potenciometro 10K linear |
LED1 e LED2 | Led vermelho 3 mm |
LDR | LDR |
S1 | Chave miniatura 1/0 |
C1 e C3 | Capacitor 1uF x 25V |
C2 e C4 | Capacitor 100nF |
CI1 | LM-358N dual opamp |
Outros | Placa CI perfuração padrão |
Borne 3 pinos parafuso |
A distancia entre os centros do LED e do LDR é cerca de 1,0 cm. Da caixa saem tres fios: o de +5 volts, o de saída do divisor de tensão e o comum a esses dois, o terra. O fio de saída do divisor de tensão vai para o capacitor C1 na entrada do primeiro amplificador pelo borne B1.
Software
Depois de conferir mais de uma vez toda a fiação, encaixe o shield no seu Arduino, conecte o sensor e depois o cabo USB no seu PC. Para ver os batimentos cardíacos de uma pessoa carregue no seu Arduino o sketch da listagem 1.
Listagem 1 |
int pinLed = 3; volatile int state = 0; void setup(){ pinMode(pinLed, OUTPUT); attachInterrupt(0, pulse, CHANGE); } void loop(){ digitalWrite(pinLed, state); } void pulse(){ state = !state; } |
attachInterrupt(pino, função, modo); |
Nesse sketch toda vez que o nível lógico no pino digital 2 mudar, a função pulse( ) será chamada, e esta vai somente complementar (mudar o estado da) a variável state. A variável state vai mudar de acordo com os batimentos do coração do experimentador e fazer o LED2 acender ou apagar conforme seu estado na função digitalWrite( )
Para testar o circuito basta você repousar a ponta de seu dedo indicador sobre o sensor e girar o cursor do potenciometro P1 para o mínimo ganho até o LED no pino 3 apagar. Depois vá aumentando o ganho até que o LED comece a piscar com os batimentos do seu coração. Depois de algum treino pressionando mais ou menos o dedo sobre o sensor é possível achar o ponto ótimo para ver o LED piscar regularmente. O ajuste fino é feito com o potenciometro.
Podemos enviar nossos batimentos cardíacos pela porta serial para o PC e ver no terminal do Windows ou do Arduino sua forma digital como uma combinação de traços horizontais com caracteres ASCII 95 e 45. Para isso acrescente ao sketch acima uma linha para iniciar a porta serial em 9600 bps e os comandos if que testam a variável state; se esta for falsa o caracter 45 será enviado para o terminal serial com a função Serial.write( ); se state for verdadeira o caracter 95 será enviado. Veja a listagem 2 e a forma dos pulsos na figura 5 abaixo. As pausas de 10 ms entre as transmissões evitam a sobrecarga do buffer da porta serial.
Listagem 2 |
int pinLed = 3; volatile int state = 0; void setup(){ pinMode(pinLed, OUTPUT); attachInterrupt(0, pulse, CHANGE); Serial.begin(9600); } void loop(){ digitalWrite(pinLed, state); if(!state) Serial.write(45); delay(10); if(state)Serial.write(95); delay(10); } void pulse(){ state = !state; } |
Figura 5: os pulsos do batimento cardíaco
Na segunda parte desse artigo vamos visualizar melhor esses pulsos cardíacos agora digitalizados numa interface gráfica na tela do seu PC usando alguns poucos comandos de uma linguagem open source e muito parecida com a do Arduino, a linguagem Processing.(Já Comentada em Posts Anteriores)...
Até Lá!
Monte seu próprio Arduino ( Muito Fácil)
As opções de Arduino
O Arduino já montado e testado pode ser adquirido em sites de comercio eletronico tanto aqui no Brasil quanto lá fora. Existe muitas opções de modelos conforme o microcontrolador embarcado, desde o mais simples com o ATmega168 com comunicação RS-232 ou USB e até aqueles com o ATmega1280 com mais memória de programa e mais entradas e saídas digitais. Mas tambem o leitor poderá montar seu proprio Arduino a partir de componentes facilmente encontrados em lojas de componentes eletronicos. Nesse caso propomos um circuito básico com o microcontrolador ATmega8 ou com o ATmega168, alguns resistores e capacitores, um regulador de tensão comum e um conjunto de conectores do tipo mini-latch para placa de circuito impresso. A placa proposta é de face simples e poderá ser confeccionada por qualquer método caseiro, como o já consagrado método térmico a partir de uma impressão a laser. A fonte de alimentação é externa à placa e pode ser qualquer carregador de baterias de aparelhos portáteis, como o de telefones celulares, que forneça tensões entre 9 e 15 volts CC. Veja o circuito completo do nosso protótipo na figura 1 e como ficou a montagem final na figura 2 abaixo.figura 1: circuito proposto para montagem
Hardware
Tanto o ATmega8 quanto o ATmega168 pode ser utilizado na montagem do nosso Arduino. Observe que no circuito não aparece o conversor TTL-RS232. Preferimos separar esse circuito da placa principal por uma boa razão: dar a opção ao montador de escolher que tipo de comunicação serial o seu Arduino terá com um PC, se RS-232 ou USB. Para a comunicação RS-232 existe o conversor MAX-232 que é um circuito integrado muito fácil de encontrar em lojas de componentes eletronicos, e por ser do tipo DIL de 16 pinos é tambem muito fácil de montar em uma pequena placa de circuito impresso e ser conectado por um cabo diretamente entre uma porta RS-232 do PC e o conector “SERIAL” que aparece no diagrama.Num outro artigo mostraremos a montagem de um circuito conversor TTL-Serial para ser usado com o nosso Arduino.Para a comunicação serial USB o conversor é o FT-232RL, um circuito integrado do tipo SMD de 28 pinos, um pouco mais difícil de encontrar no comercio, bem mais caro que o MAX-232 e de montagem mais complicada numa placa de circuito impresso caseira devido ao tamanho e espaçamento entre seus pinos. Mas tanto um tipo quanto o outro de conversor funciona normalmente com o Arduino. A grande vantagem da USB é que todo PC moderno tem várias dessas portas disponíveis, e só os de mesa, os desktop, ainda estão vindo com duas ou tres portas RS-232.
Descrição do Circuito
O microcontrolador é alimentado com +5 volts nos pinos 7 e 20 provenientes do regulador de tensão integrado LM7805, se o jumper JMP1 estiver na posição “EXT”. Os capacitores C1 a C4 formam os filtros CC de entrada e de saída do regulador. No conector J1 entramos com uma tensão de +9 volts a +15 volts de uma fonte externa ou de um carregador comum de baterias com o positivo no pino central.O diodo D1 serve de proteção para o circuito no caso de o pino central ser negativo. O LED1, vermelho, acende se a tensão de alimentação do circuito estiver correta. Essa mesma tensão externa tambem é disponibilizada no primeiro pino do conector “POWER”. A tensão de +5 volts do regulador LM7805 alem de ser disponibilizada nos pinos dos conectores “POWER” e “SENSOR” segue tambem para o conector “SERIAL” para alimentar a placa externa com o conversor RS-232.
À direita do diagrama temos o microcontrolador e os conectores ICSP, os dois digitais e o analógico. São 14 pinos digitais (D0 a D13) e 6 analógicos (A0 a A5). O pino de entrada de referência (AREF) para o conversor A/D do Arduino fica no segundo conector digital. O LED de teste e o pino 3 do ICSP estão ligados no pino digital D13. Na área tracejada vemos um cristal de 16Mhz e dois capacitores de 22pF que formam o circuito de relógio para o microcontrolador. Esse conjunto cristal-capacitores pode ser substituido por um ressonador cerâmico de 16Mhz que já inclui os dois capacitores no mesmo encapsulamento.
O microcontrolador uma vez configurado pelo bootloader do Arduino é resetado pelo último pino do PORT C (pino 1do microcontrolador), onde tambem temos um botão de RESET. Esse mesmo sinal de RESET segue para o pino 5 do ICSP e, atraves de um capacitor de 100nF, para o circuito conversor serial externo, para onde vão tambem os pinos digitais D0 e D1 que normalmente são reservados para a comunicação serial do Arduino com um computador PC ou com outro Arduino. Nesse conector “SERIAL” pode ser ligado um circuito conversor RS-232 ou um USB. Se for usado um conversor USB o jumper JMP1 deve ser mudado para a posição “USB” e com isso o Arduino passa a ser alimentado pela tensão +5 volts da porta USB do computador PC. É interessante observar que se não dispusermos de um carregador de baterias para conectarmos em J1 nosso Arduino pode ser alimentado por uma fonte externa de +5 volts diretamente atraves do conector “POWER”. O microcontrolador aparece no meio da placa.
Todos os pinos digitais e analógicos obedecem as mesmas posições e distanciamentos do Arduino padrão. Na parte de cima ficam os conectores digitais e à direita destes o conector “SERIAL” que acrescentamos para ligarmos a placa do conversor serial que será montada à parte. Na parte de baixo da placa está o jumper para selecionarmos que interface serial estamos usando, se RS-232 ou USB, e o conector analógico e o de tensões disponíveis para outros circuitos. À esquerda deste acrescentamos tambem um conector de tres pinos, o “SENSOR”, que é uma extensão do pino analógico A0, a tensão de +5 volts e o terra num só conector. À direita da placa, temos o botão de RESET e acima dele o conector “ICSP”. Mais abaixo do RESET o conector de entrada de tensão para alimentar o Arduino. Os outros componentes são os capacitores e resistores, o regulador de tensão e os dois LEDs. O LED vermelho acende para indicar que o Arduino está corretamente alimentado e o LED verde é o que vai conectado ao pino digital D13 do Arduino e indica quando carregamos programas para o microcontrolador. Em nosso Arduino utilizamos um ressonador cerâmico de 16 Mhz em vez do cristal e dois capacitores de 22pF que aparecem no diagrama da figura 1. Nossa placa tem somente quatro pequenos jumpers.
figura 2
Lista de materiais para a montagem do Arduino proposto
Item | Componente | qtde | Obs. |
1 | Soquete DIL 28 pinos | 1 | Ou 2x DIL de 14 pinos |
2 | ATmega8 | 1 | ou ATmega168 |
3 | Cristal 16 Mhz | 1 | Ou ressonador cerâmico 16 Mhz |
4 | Regulador LM-7805 | 1 | Não precisa dissipador |
5 | Diodo 1N4148 | 1 | qualquer um da série 1N414x |
6 | LED 5 mm vermelho | 1 | |
7 | LED 5 mm verde | 1 | |
8 | Capacitor 100uFx25V | 1 | Tipo axial |
9 | Capacitor 10uFx25V | 1 | Tipo axial |
10 | Capacitor 100nFx100V | 3 | Tipo poliester |
11 | Capacitor 22pFx100V | 2 | Dispensados se usar ressonador |
12 | Resistor 220 ohms x 1/8W | 2 | Tipo cerâmico |
13 | Resistor 10 Kohms x 1/8W | 1 | |
14 | Botão tipo campanhia | 1 | Micro-chave para circuito impresso |
15 | Jumper 3 pinos | 1 | Jumper com espaçamento 2,54 mm |
16 | Conector mini-latch 8 pinos fêmea | 2 | Para os pinos digitais |
17 | Conector mini-latch 6 pinos fêmea | 1 | Para os pinos analógicos |
18 | Conector mini-latch 6 pinos fêmea | 1 | Para os pinos de tensões externas |
19 | Barra de pinos 6 pinos 90 graus | 1 | Para a placa serial |
20 | Conector mini-latch 3 pinos fêmea | 1 | Para a entrada de sensor |
21 | Barra de pinos 2x3 fêmea | 1 | Para o ICSP |
22 | Conector alimentação femea | 1 | tipo jack para circuito impresso |
A placa de Circuito Impresso
A placa de circuito impresso do nosso Arduino tem 7,5 cm por 5,5 cm e é de face simples. Veja na figura 3 o lado da solda e na figura 4 uma sugestão de serigrafia no lado dos componentes na placa.figura 3
figura 4
figura 5
Uma vez pronta a placa de circuito impresso, o nosso Arduino pode ser todo montado em umas poucas horas, dependendo da experiência em montagens eletronicas do leitor. As unicas recomendações são para conferir mais de uma vez a montagem dos componentes polarizados, como o diodo, os capacitores eletrolíticos e os LEDs, e para se certificar que o microcontrolador está corretamente alojado e orientado no seu soquete. Confira tambem se os quatro jumpers (são quatro pedaços de fios finos) foram corretamente soldados nos seus respectivos lugares. Por fim, coloque o strap de JMP1 na posição “EXT”. Alimentando o Arduino
Com o hardware do Arduino montado já podemos alimentá-lo, embora ainda não possamos controlar nada com ele pois não temos nenhum programa carregado. Você pode alimentar o Arduino de duas maneiras diferentes: ou com uma fonte externa ou um carregador para aparelhos portáteis com tensões entre 9V e 15V, como o da figura 6 abaixo; ou diretamente com uma bateria comum de 9 volts com um cabo adaptado para o plug da bateria e para o plug do módulo, veja a figura 6. O positivo da fonte deverá ser o pino central do conector macho que vai ligado ao Arduino.figura 6
Ao conectar qualquer dessas fontes de tensão ao Arduino somente o LED vermelho deverá acender de imediato indicando que o módulo está alimentado corretamente. Num outro artigo vamos montar um programador para o bootloader e o cabo serial e fazer nossos primeiros experimentos com o nosso Arduino.É isso aí, agora se você ja fez seu arduino ou ja tem um siga a página principal de Arduino do Blog e vá seguindo os tutoriais! Bom Proveito!
Não Me Responsabilizo por Nada Aqui escrito, se pegar FOGO é por sua Conta!
Efeito Parecido com Circuito
Vamos criar um efeito abstrato que lembra um circuito de computador utilizando filtros, modos de blend e alguns outros recursos do Photoshop.
01. Pressione Ctrl+N para criar um novo documento, defina os valores de 500x500 pixels, 72 dpi´s, modo de cor em RGB e fundo transparente, pressione Ok, pressione a letra D do teclado para resetar as cores de Foreground e Background para pretoe branco, vá em Filter> Render> Clouds e depois em Filter> Blur> Motion Blur, defina o valor de Angle em 0º e Distance em 999 pixels, vá em Filter> Stylize> Find Eges, pressione Ctrl+J para duplicar a layer, vá em Edit> Transform> Rotate 90º CW, mude o modo de blend da layer para Darken, pressione Ctrl+E para mesclar as layer, vá em Filter> Stylize> Glowing Edges e defina o valor de 1 pixels para Edge Width, 20 pixels para Edge Brightness e 3 pixels para Smoothness.
01. Agora vá em Image> Adjustments> Brightness/Contrast e defina o valor de Brightness em 0 e Contrast em +40, pressione Ok, pressione Ctrl+U para abrir a caixa de Hue/Saturation, marque a opção Colorize e defina o valor de Hue em 180, Saturation em 100 e Lightness em 0, pressione Ok, vá em Edit> Transform> Perspective e distorça a imagem como na foto abaixo, pressione Enter para finalizar a transformação.
03. Pressione Ctrl+J para duplicar a layer, vá em Filter> Blur> Gaussian Blur e defina o valor de Radius em 4,4 pixels e pressione Ok, mude o modo de blend da layer para Screen, pressione Ctrl+E para mesclar as layers, pressione Ctrl+N para criar um novo documento, repita todos os passos, no final pressione Ctrl+A para selecionar toda área do documento, Ctrl+C para copiar, volte ao documento que estamos trabalhando e pressione Ctrl+V para colar a imagem, vá em Filter> Render> Lighting Effects e defina os valores abaixo.
04. Defina a opacidade da layer em 50% e mude o modo de blend para Lighten, no final sua imagem estará como a da foto abaixo.
Site de origem: http://www.webdesign.org/photoshop/special-effects/abstract-electrical-circuit-tutorial.6964.html
Imagem Pulando da moldura
Descrição: Hoje veremos como estilizar uma imagem para que ela "pule" para fora de sua moldura, para isso usaremos diversas ferramentas e recortaremos a imagem.
01. Pressione Ctrl+O e abra uma foto qualquer no Photoshop, pressione Ctrl+Shift+Alt+N para criar uma nova layer, pressione a letra M do teclado para selecionar a Rectangular Marquee Tool, crie uma seleção retangular, pressione a letra D do teclado para resetar as cores de Foreground e Background para preto e branco, pressione a letra X do teclado para alternar as cores de Foreground e Background, sua cor de Foreground deve ser a branca, pressione Alt+Backspace (a tecla acima do Enter) ou pressione a letra G do teclado para selecionar a Paint Bucket Tool e clique no documento pare preencher a seleção com a cor branca, vá em Select> Modify> Contract e defina o valor de 15 a 20 pixels, pressione Ok e depois pressione Delete para deletar a parte interna do retângulo, vá em Edit> Transform> Perspective e distorça o retângulo como na foto abaixo, pressione Enter para finalizar a transformação.
02. Pressione a letra W do teclado para selecionar a Magic Wand Tool, a parte interna do retângulo como na foto abaixo.
03. Clique na layer da foto e pressione Ctrl+J para duplicar a parte selecionada para outra layer, clique na layer da imagem original e vá em Layer> Hide Layers para retirar a visibilidade da layer.
04. Clique na layer do frame e defina a opacidade em 50%, clique na layer da imagem original e vá em Layer> Show Layers para ativar a visibilidade da layer, selecione a parte do tanque que sairá do frame.
05. Pressione Ctrl+Shift+I para inverter a seleção, pressione Delete, mova a layer para o topo da paleta de layers, sua imagem deverá ficar como a da foto abaixo.
06. Pressione Ctrl+Shift+Alt+N para criar uma nova layer, deixe esta layer abaixo de todas as outras, escolha um cor qualquer e pressione Alt+Backspace (a tecla acima do Enter) ou pressione a letra G do teclado para selecionar a Paint Bucket Tool e clique no documento para preencher a layer com a cor escolhida, no final sua imagem ficará como a da foto abaixo.
Site de origem: http://www.webdesign.org/photoshop/3d-effects/3d-photo-tutorial.19330.html
Assinar:
Postagens (Atom)