Headset Logitech G230 um bom headset de entrada

Headset Logitech G230 um bom headset de entrada

O headset Logitech G-230 tem muito o que oferecer quando o assunto é preço e conforto.
A posição de descanso do fone é muito boa e pratica de ser usada, os cabos tem um bom comprimento e o acabamento do fone é bom, além de ter os earcups removíveis.

Posted by medigaco_wp in Headset, perifericos, 0 comments
Reviews Monitor LG 34UC79G-B

Reviews Monitor LG 34UC79G-B

O monitor da LG 34UC79G tem muito o que oferecer quando o assunto é multimídia, multitarefas e também aos gamers que desejam imersão nos jogos com tela IPS e função SplitScreen.

Posted by medigaco_wp in Monitor, periferico, perifericos, 0 comments
Strain Gage,Extensômetria, Deformação, eletrônica e códigos para microcontrolador.

Strain Gage,Extensômetria, Deformação, eletrônica e códigos para microcontrolador.

 

 Strain Gage,Extensômetria, Deformação, eletrônica e códigos para microcontrolador.
Conversão A/D
No mundo físico parâmetros como temperatura, força, pressão, umidade, velocidade entre outros são sinais analógicos. Essas grandezas físicas são convertidas em sinais elétricos, para podermos trabalhar com esses dados com o auxilio de micro controladores, devemos converter esses sinais usando um conversor analógico digital (ADC) que é um componente eletrônico que converte sinais para uma forma discreta.
Os conversores analógicos digitais são os dispositivos mais usados no mundo para a aquisição de dados, o conversor usado neste projeto é o ADC0808 com uma resolução de 8 bits possuindo oito entradas de sinais analógicos com seu controle feito de maneira multiplexada.
O conversor analógico digital ADC0808 usa o método de aproximação sucessiva para transformar os sinais lidos em dados digitais.
O design do ADC0808 foi otimizado pela incorporação dos mais desejados aspectos vistos em outros conversores, o dispositivo oferece alta velocidade de conversão, precisão e dependência mínima em relação a mudanças na temperatura ambiente.
Principais Características.
1.  Fácil interface com micro controladores.
2.  Não necessita de ajuste de zero ou de fundo de escala.
4.  Oito canais de entradas multiplexados.
5. Com alimentação de 5V os sinais de entrada podem variar de 0 a 5V.
6.  Tensões de saída compatível com as especificações TTL.

                 
Conforme Trietley (1986), os conversores A/D por aproximação sucessiva são os mais comuns entre os conversores A/D, permitem uma conversão rápida, proporcionando uma gama de 100.000 ou mais conversões por segundo.
Na técnica de aproximação sucessiva, é utilizada um algoritmo para converter a entrada analógica em digital.
Este algoritmo consiste em ajustar o MSB para 1 e todos os outros bits para 0. O comparador compara a saída do conversor D/A (Vd) com o sinal da entrada analógica (Ve). Se Vd > Ve, o 1 é removido do MSB e enviado para o próximo bit mais significativo. Se Ve > Vd, o MSB permanece como 1 e o próximo bit mais significativo também recebe 1. Assim o 1 é deslocado e testado em cada bit do decodificador D/A até o final do processo, para obter o valor binário equivalente.
 

 

 

 

Fluxograma da aproximação sucessiva, Tocci’s Digital Systems: Principles and Applications, 10th edition – Pearson Prentice Hall
 Pinagem ADC0808

conversor analogico digital

  
         O ADC0808 possui oito entradas, para selecionar a que será usada para receber os sinais do extensômetro devemos enviar para o ADC 3 bits nos pinos 25,24,23.

 

Tabela de seleção de entradas National Semiconductor  – Data sheet ADC0808 – Outubro de 1999
O sinal enviado pelo extensômetro depois de amplificado e tratado entrará no pino 26 (IN0), para selecionar esse canal é preciso enviar 3 bits 0 (zero), ou aterrar os 3 pinos do seletor, neste projeto os 3 pinos foram aterrados, o sinal analógico  é convertido em um sinal digital com 8 bits de resolução que no nosso caso permite uma mudança de estado a cada 20mV.
De acordo com o diagrama de tempo do ADC podemos dizer quais os requisitos para realizar a leitura dos dados processados pelo ADC, e definir uma freqüência de operação para atualização.
De acordo com o data sheet as freqüências podem estar dentro da faixa de 10 a 1280 Khz, para gerar um clock dentro destas especificações foi usado um CI 555 e a freqüência estipulada foi de 320Khz.
No micro controlador a porta P0 recebe valores de 0x00 até 0xFF
que em decimal equivaleriam a 0 até 255 uma multiplicação simples por 2 nos permite trabalhar com números decimais de 1 a 510 sendo uma aproximação simples e efetiva dos 0 a 5kg que iremos exibir em nosso display, só nos restando fazer um jogo com casas decimais que foi facilmente implementado no código.
DisplayLCD, como inicializar sem uma biblioteca pronta.
Conforme visto em: http://www.electronica-pt.com/index.php/content/view/247/37/ (2009), os LCD são formados por material que se denomina cristal líquido. As moléculas desse material são distribuídas entre duas lâminas transparentes polarizadas. Essa polarização é orientada de maneira diferente nas duas lâminas, de forma que estas formem eixos polarizadores perpendiculares, como se formassem um ângulo de 90º. As moléculas de cristal líquido são capazes de orientar a luz.
A base da iluminação de um LCD é a luz fornecida por uma lâmpada CCFL ou um conjunto de LEDS. Nos LCD monocromáticos, cada ponto da tela corresponde a um ponto da imagem.
Um pixel é a menor unidade de uma imagem, o número de pixels no display determina a resolução do LCD.

 

Os LCDs são amplamente usados em conjunto com micro controladores para mostrar a informação visualmente, os LCDs possuem uma tabela de caracteres ASCII e símbolos matemáticos em sua memória.
 

 

*

 

Sinais Enviados para o LCD
O LCD requer três sinais de controle que devem ser enviados pelo micro controlador.
Enable (E) – Este sinal permite acessar o display através das instruções R/W e RS.
Quando enable tem nível lógico baixo o display ignora os sinais vindos de R/W e RS, quando enable tem nível lógico alto o display checa os estados desses dois controladores, e responde de acordo.
Read/Write (R/W) Ler e Escrever- Determina a direção em que os dados fluem entre o LCD e o micro controlador, quando R/W tem nível lógico baixo os dados enviados pelo micro controlador são escritos no LCD, quando R/W tem nível lógico alto os dados são lidos do LCD.
Register select (RS) Seletor de Registros – De acordo com os dados nesse controlador o LCD interpreta o tipo de dado que está sendo enviado pelo micro controlador.
Quando RS tem nível baixo uma instrução está sendo escrita no LCD, quando o nível é alto um caractere ou mais está sendo escrito.
E = 0 Acesso ao LCD desabilitado
  = 1 Acesso ao LCD habilitado
R/W = 0 Escrevendo dados no LCD
  = 1Lendo dados do LCD
RS= 0 Uma instrução foi enviada ao LCD
    = 1 Um caractere foi enviado ao LCD
Escrevendo dados no LCD
Enviar dados para o LCD requer alguns passos:
1) Setar o bit R/W bit como 0 (zero).
2) Setar o bit RS como 0 (zero) ou 1 (um) (instrução ou caractere).
3) Enviar dados para as linhas de dado.
4) Setar o bit E como 1 (um).
5) Setar o bit E como 0 (zero).
Lendo dados
1) Setar o bit R/W como 1 (um)
2) Setar o bit RS como 0 (zero) ou 1 (um) (instrução ou caractere).
3) Ler dados das linhas de dados
4) Setar o bit E como 1 (um).
5) Setar o bit E como 0 (zero).
5.1.2.1     Pinagem do LCD

*

 

Display LCD 20×4 – descrição dos pinos. (Data Sheet MGD2004D-FL-YBS – 26 de junho de 2006)
Inicialização do LCD
Antes de usar o display LCD para nosso objetivo, ele deve ser inicializado via reset interno ou pelo envio de um conjunto de instruções. Como nosso projeto foi concebido com a idéia de conectar o display a um micro controlador, escolhemos a inicialização por instruções.
Inicializar um display LCD com instruções é um processo simples, abaixo temos um fluxograma que indica todos os passos.

 

Fluxograma de inicialização por instruções do Display LCD (Ajay Bhargav – http://www.8051projects.net/)
De acordo com o fluxograma podemos observar que o display LCD é inicializado conforme a seguinte seqüência
1)    Enviar o comando 0x30 – Usando a interface de 8 bits
2)    Esperar 20ms
3)    Enviar o comando 0x30 – Usando a interface de 8 bits
4)    Esperar 20ms
5)    Enviar o comando 0x30 – Usando a interface de 8 bits
6)    Esperar 20ms
7)    Enviar o conjunto de instruções.
8)    Enviar o comando 0x01 para limpar o LCD
9)    Definir o modo de incremento.

Teclados são dispositivos que realizam a interface homem máquina e os teclados matriciais como o usado neste projeto são os mais conhecidos devido sua arquitetura simples e sua fácil integração com micro controladores.

*

 

Lendo os dados enviados por um teclado
Existem vários métodos de se ler dados enviados por um teclado e eles basicamente se diferenciam pela maneira com que são conectados a um micro controlador, mas a lógica permanece a mesma.
No micro controlador as colunas são definidas como pinos de entrada e as linhas como pinos de saída.

 
 
 

 

 

Teclado matricial
Para detectar qual tecla foi pressionada todas as linhas recebem nível lógico baixo e todas as colunas recebem nível alto, o micro controlador espera alguma mudança de estado nas colunas, se uma tecla foi pressionada o nível baixo será enviado para a entrada do micro processador, pois as colunas foram definidas como pinos de entrada.
  
A linguagem C
De acordo com Aitken, Jones (2002), a linguagem C é poderosae flexível, o que você conseguirá programando em C será somente limitado por sua imaginação.
A linguagem C não restringe a criação, C é usado em projetos como sistemas operacionais, editores de texto, gráficos, tabelas e até mesmo compiladores para outras linguagens.
C é uma linguagem portável, portabilidade significa que um programa escrito em C para um sistema, por exemplo, um sistema IBM, pode ser compilado e funcionar em outro sistema com pouca ou nenhuma modificação.
C é modular, o código em C pode e deve ser escrito em rotinas chamadas funções, estas funções podem ser reusadas em outras aplicações ou programas.
De acordo com o data Sheet Atmel 8-bit Microcontroller with 8K Bytes In-System Programmable Flash, o AT89S52 é um integrado de baixo consumo e alta performance com 8 Kbytes de memória flash programável. O dispositivo é compatível com os padrões industriais de conjunto de instruções 80C51.
O AT89S52 possui 32 linhas de entrada e saída, Watchdog timer, dois ponteiros de dados, três contadores / temporizadores de 16 bits, porta serial com comunicação full duplex, oscilador integrado e suporte a dois modos de economia de energia.
Ao combinar uma CPU versátil de 8-bit com memória flash programável no sistema o Atmel AT89S52 é um micro controlador poderoso que fornece uma solução altamente flexível e de custo eficaz para muitas aplicações de controles incorporados.
Gostaríamos de citar a família ATMEGA da Atmel que possui funções muito pertinentes ao nosso trabalho como o ADC integrado e uma velocidade consideravelmente maior o que nos facilitaria em muito o desenvolvimento deste projeto, mas pelos motivos citados acima e por fins didáticos decidimos  descartar o uso desta linha de micro controladores.
 
*

 

 
O que nos motivou a escolher o micro controlador AT89S52 foi a familiaridade que adquirimos com o mesmo durante o curso e para mostrar o poder da família 8051. Nosso intuito foi o de mostrar que as aulas de micro controladores nos deram embasamento suficiente para alçarmos vôos maiores.
O condicionador de sinal 1B31 da Analog Devices pode ser dividido em três partes, um amplificador de instrumentação com alta precisão, um ajustador de excitação da ponte e um conjunto de filtros.
O 1B31 pode ser usado em uma grande variedade de sensores como transdutores, medidores de força, torque e pressão. Ideal para aplicações industrias pois é pouco sensível a mudanças ambientais e a ruídos.
 

 

O 1B31 nos proporciona uma série de facilidades entre elas podemos citar:
·         Ajuste de tensão de excitação da ponte.
·         Ajuste de offset da saída
·         Ajuste de ganho.
O ganho do nosso amplificador é ajustado seguindo a seguinte equação:
*
Onde RG é o resistor de ganho que vai conectado entre os pinos 3 e 4.
Com uma tensão de fundo de escala de 5,375 mV e com uma resolução de 0,2V e com 250 passos nossa tensão de saída ideal seria de 4,9 V, o que resulta em uma ganho de 907 usando uma resistência de 80 ohms.

 

 
Vídeo do projeto funcionado
Código fonte:
Original para 8051, podendo ser adaptado par arduino entre outros.
 
#include <REGX52.H>        // Biblioteca do 8051
#include<intrins.h>     // Usado por causa do _nop_();
#include<string.h>
/* The intrins.h include file contains prototypes for routines
that instruct the compiler to generate intrinsic code.
Mais Detalhes em http://www.keil.com/support/man/docs/c166/c166_intrins_h.htm */
#define ADC_data P0            // Porta P0 sera ligada ao barramento de dados do ADC
#define LCD_data P2             // Porta P2 sera ligada ao barramento de dados do LCD
#define LCD_rs P1_0             // RS=1 envia dados ; RS=0 Envia Instruções
#define LCD_rw P1_1            // RW=1 Faz leitura ; RS=0 Escreve
#define LCD_en P1_2           // On/Off *VIDE DATA SHEET*
#define ADC_start P1_3 // Inicia Conversão
#define ADC_eoc P1_4   // Termina a Conversão
#define ADC_oe P1_5           // Libera a Saída
#define ADC_ale P1_6   // Inicia Conversão
#define keyport P3        // Barramento de dados para o teclado
#define col1 P3_0         // Setamos aqui as colunas para fazer a varredura, col1 a col4
#define col2 P3_1
#define col3 P3_2
#define col4 P3_3
#define TRUE 1                   // Define 1 como verdadeiro
#define FALSE 0                          // Define 0 como falso
void LCD_poweron(void); // Delay de 15ms para inicialização do LCD (cristal de 11.0592)
void LCD_busy(void);    // Delay para evitar Busy Flag
void LCD_instruction(unsigned char var); // Envio de Instruções ao LCD
void LCD_senddata(unsigned char var);      // Envio de Dados ao LCD
void LCD_sendstring(unsigned char *var); // Envio de Dados ao LCD
void LCD_sendvariavel(int var); // Envio de Variavel ao LCD
void ADC_poweron(void); // Conjunto de Instruções para partida do ADC
void tec_inicio(void);  // Inicializa porta P3 com os valores desejados
int le_tecla(void);     // Função responsável pela leitura de dados do teclado
int teclado = 0;
signed int leitura1=0, leitura2=0, leitura3=0, leitura4=0, leitura5=0, leituras=0;
signed int leitura6=0, leitura7=0, leitura8=0, leitura9=0, leitura10=0;
signed int leitura1x=0, leitura2x=0, leitura3x=0, leitura4x=0, leitura5x=0, leiturasx=0;
signed int leitura6x=0, leitura7x=0, leitura8x=0, leitura9x=0, leitura10x=0;
signed int valor=0;
signed int temp_digito=0;
signed int temp_digito1=0;
signed int temp_tara=0;
signed int condicao=0;
signed int condicaox=0;
signed int temp=0;
signed int temp1=0;
signed int temp2=0;
signed int tempx=0;
signed int temp1x=0;
signed int temp2x=0;
signed int tara=0;
int x;
signed int tara_mestre1=0;
signed int tara_mestre2=0;
signed int unidade=0,dezena=0,centena=0,milhar=0;
signed int unidade2=0,dezena2=0,centena2,milhar2=0;
signed int unidadex=0,dezenax=0,centenax=0,milharx=0;
signed int unidade2x=0,dezena2x=0,centena2x,milhar2x=0;
void main(void)
         {
         inicio:
        
         LCD_poweron();                // 15ms delay
         LCD_poweron();                // 15ms delay
         LCD_instruction(0x38); // Inicialização de display em 8 bits
         LCD_instruction(0x38); // Inicialização de display em 8 bits
         LCD_instruction(0x0F); // Modo de funcionamento
         LCD_instruction(0x01); // Limpa a Tela do Display
         LCD_instruction(0x06); // Tipo de Incremento
         LCD_instruction(0x80); // Seta cursor na 1ª posição da 1ª linha
         LCD_sendstring(“   FIEL-TCC 2009    “); // texto a ser enviado
         LCD_instruction(0xC0); // Seta Cursor na 1ª posição da 2ª linha
         LCD_sendstring(“——————–“); // texto a ser enviado
         LCD_instruction(0x94); // Seta Cursor na 1ª posição da 3ª linha
         LCD_sendstring(“1: LEITURA”); // texto a ser enviado
         LCD_instruction(0xD4); // Seta Cursor na 1ª posição da 4ª linha
         LCD_sendstring(“2: LEITURA COM TARA”); // texto a ser enviado
        
         /*      
                   O endereço da 3ª e 4ª linhas
                   São continuações da 1ª e 2ª
                   os endereços de inicio são:
                   1ª:0x80     
                   2ª:0xC0
                   3ª:0x94
                   4ª:0xD4
         */
         tec_inicio(); // Inicialização do Teclado
        
while(1)  
         {
                   teclado = le_tecla();   
                  
         switch (teclado)                   
                   {
                            // achar as posições fixas na tela para dar update de dados somente nos numeros e
                            // nao no texto todo.
                  
                   case 1:                // Se nao funcionar tentar diminuir o lcd_busy do sendvariavel
                                      {
                                      LCD_instruction(0x01); // Limpa a Tela do Display
                                      x=0;
                                     
                                      while(x<5)
                                      {
                                      LCD_instruction(0x80); // Seta cursor na 1ª posição da 1ª linha
                                      LCD_sendstring(“1:Continua Leitura”); // texto a ser enviado
                                      LCD_instruction(0xC0); // Seta Cursor na 1ª posição da 2ª linha
                                      LCD_sendstring(“2:TARA”); // texto a ser enviado
                                      //Iniciando o ADC                                                                                                                                          
                                      ADC_poweron();
                                      // Código responsável por tirar uam média do valor lido para evitar discrepâncias
                                      leitura1 = ADC_data;
                                      leitura2 = ADC_data;
                                      leitura3 = ADC_data;
                                      leitura4 = ADC_data;
                                      leitura5 = ADC_data;
                                      leitura6 = ADC_data;
                                      leitura7 = ADC_data;
                                      leitura8 = ADC_data;
                                      leitura9 = ADC_data;
                                      leitura10 = ADC_data;
                                       
                                      leituras = (leitura1 + leitura2 + leitura3 + leitura4 + leitura5 + leitura6 + leitura7 + leitura8 + leitura9 + leitura10);
                                      temp_digito = (leituras/10);
                                      temp = temp_digito*2;
                                      temp2 = temp_digito*19.6; // Conversão para newton e exibição correta 9,8*2
                                     
                                      // Separando o valor lido em 4 partes
                                     
                                      unidade=temp%10;   
                                      dezena=(temp%100)/10;
                                      centena=(temp/100)%10;
                                      milhar=temp/1000;
                                     
                                      tara_mestre1=((unidade) + (10*dezena) + (100*centena) + (1000*milhar));
                                      unidade2=temp2%10;   
                                      dezena2=(temp2%100)/10;
                                      centena2=(temp2/100)%10;
                                      milhar2=temp2/1000;
                           
                                      // Somando 0x30h para cada variavel.
                                      // 0x30h é o endereço onde começa o Número zero da tabela ASCII.
                                      // Esta parte se refere aos valores em kg (MASSA)
                                      milhar+=0x30;
                                      centena+=0x30;
                                      dezena+=0x30;
                                      unidade+=0x30;
                                      // Somando 0x30h para cada variavel
                                      // Esta segunda parte se refere aos valores em Newton
                                      milhar2+=0x30;
                                      centena2+=0x30;
                                      dezena2+=0x30;
                                      unidade2+=0x30;
                                     
                                     // Enviando cada trecho dos valores lidos ao LCD                 
                                      LCD_instruction(0x94); // Seta Cursor na 1ª posição da 3ª linha
                                      LCD_sendstring(“MASSA:”);        // Envia uma string para detalhar a leitura
                                      LCD_sendvariavel(milhar);
                                      LCD_sendvariavel(centena);
                                      LCD_sendstring(“.”);  // Envia uma string para detalhar a leitura
                                      LCD_sendvariavel(dezena);
                                      LCD_sendvariavel(unidade);
                                      LCD_sendstring(“0”); // Envia uma string para detalhar a leitura
                                      LCD_sendstring(” (kg)”);     // Envia uma string para detalhar a leitura
                                      ADC_oe=0; // Desliga a leitura de dados
                                      LCD_instruction(0xD4); // Seta Cursor na 1ª posição da 3ª linha
                                      // Enviando cada trecho dos valores lidos ao LCD
                                      LCD_sendstring(“PESO:”); // Envia uma string para detalhar a leitura
                                      LCD_sendvariavel(milhar2);
                                      LCD_sendvariavel(centena2);
                                      LCD_sendstring(“.”);  // Envia uma string para detalhar a leitura
                                      LCD_sendvariavel(dezena2);
                                      LCD_sendvariavel(unidade2);
                                      LCD_sendstring(“0”); // Envia uma string para detalhar a leitura
                                      LCD_sendstring(” (N)”);       // Envia uma string para detalhar a leitura
                                      ADC_oe=0; // Desliga a leitura de dados
                                      tec_inicio();
                                     
                                      //teclado=0;
                                      //teclado=le_tecla();
                                      //if((teclado=le_tecla())!=0);
                                      x++;
                                      }
                                      break;
                                      }
                                     
                   case 2:
                                      {
                                     
                                     
                                       // Temporario Para teste de direcionamento
                                      // tarar antes de entra no case e continuar lendo dentro do case caso a pessoa queira continuar
                                      // para pegar outrop valor de tara ela deve retonar ao menu principal
                                     
                                     
                                      x=0;
                                      LCD_instruction(0x01); // Limpa a Tela do Display
                                      LCD_instruction(0x80); // Seta cursor na 1ª posição da 1ª linha
                                      LCD_sendstring(“1:Continua Leitura”); // texto a ser enviado
                                      LCD_instruction(0xC0); // Seta Cursor na 1ª posição da 2ª linha
                                      LCD_sendstring(“2:TARA”); // texto a ser enviado
                                                                                                                                   
                                     
                                      while(x<5)
                                      {
                                      condicaox=0;
                                      tara_mestre2=0;
                                      temp_digito=0;
                           
                                      ADC_poweron();
                                      leitura1x = ADC_data;
                                      leitura2x = ADC_data;
                                      leitura3x = ADC_data;
                                      leitura4x = ADC_data;
                                      leitura5x = ADC_data;
                                      leitura6x = ADC_data;
                                      leitura7x = ADC_data;
                                      leitura8x = ADC_data;
                                      leitura9x = ADC_data;
                                      leitura10x = ADC_data;
                                      leiturasx = (leitura1x + leitura2x + leitura3x + leitura4x + leitura5x + leitura6x + leitura7x + leitura8x + leitura9x + leitura10x);
                                      temp_tara=(leiturasx/10);
                                                                          
                                      tempx = temp_tara*2;
                                      temp2x = temp_tara*19.6; // Conversão para newton e exibição correta 9,8*2
                                     
                                      // Separando o valor lido em 4 partes
                                    
                                      unidadex=tempx%10;   
                                      dezenax=(tempx%100)/10;
                                      centenax=(tempx/100)%10;
                                      milharx=tempx/1000;
                                     
                                      tara_mestre2=((unidadex) + (10*dezenax) + (100*centenax) + (1000*milharx));
                                      unidade2x=tara_mestre2%10;   
                                      dezena2x=(tara_mestre2%100)/10;
                                      centena2x=(tara_mestre2/100)%10;
                                      milhar2x=tara_mestre2/1000;
                                      milharx+=0x30;
                                      centenax+=0x30;
                                      dezenax+=0x30;
                                      unidadex+=0x30;
                                      // Somando 0x30h para cada variavel
                                      // Esta segunda parte se refere aos valores em Newton
                                      milhar2x+=0x30;
                                      centena2x+=0x30;
                                      dezena2x+=0x30;
                                      unidade2x+=0x30;
                                                                                                      
                                      condicaox = (tara_mestre2 – tara_mestre1);
                                     
                                                                          
                                      if (condicaox >= 0)
                                      {
                           
                                      //Iniciando o ADC                                                                                                                                          
                                      ADC_poweron();
                                      // Código responsável por tirar uam média do valor lido para evitar discrepâncias
                                                                            
                                      //temp_digito = condicao;
                                      tempx = condicaox;
                                      //temp = temp_digito*2;
                                      temp2x = condicaox*9.8; // Conversão para newton e exibição correta 9,8*2
                                     
                                      // Separando o valor lido em 4 partes
                                     
                                      unidadex=tempx%10;   
                                      dezenax=(tempx%100)/10;
                                      centenax=(tempx/100)%10;
                                      milharx=tempx/1000;
                                      unidade2x=temp2x%10;   
                                      dezena2x=(temp2x%100)/10;
                                      centena2x=(temp2x/100)%10;
                                      milhar2x=temp2x/1000;
                           
                                      // Somando 0x30h para cada variavel.
                                      // 0x30h é o endereço onde começa o Número zero da tabela ASCII.
                                      // Esta parte se refere aos valores em kg (MASSA)
                                      milharx+=0x30;
                                      centenax+=0x30;
                                      dezenax+=0x30;
                                      unidadex+=0x30;
                                      // Somando 0x30h para cada variavel
                                      // Esta segunda parte se refere aos valores em Newton
                                      milhar2x+=0x30;
                                      centena2x+=0x30;
                                      dezena2x+=0x30;
                                      unidade2x+=0x30;
                                     
                                     // Enviando cada trecho dos valores lidos ao LCD                 
                                      LCD_instruction(0x94); // Seta Cursor na 1ª posição da 3ª linha
                                      LCD_sendstring(“MASSA: “);       // Envia uma string para detalhar a leitura
                                      LCD_sendvariavel(milharx);
                                      LCD_sendvariavel(centenax);
                                      LCD_sendstring(“.”);  // Envia uma string para detalhar a leitura
                                      LCD_sendvariavel(dezenax);
                                      LCD_sendvariavel(unidadex);
                                      LCD_sendstring(“0”); // Envia uma string para detalhar a leitura
                                      LCD_sendstring(” (kg)  “);   // Envia uma string para detalhar a leitura
                                      ADC_oe=0; // Desliga a leitura de dados
                                      LCD_instruction(0xD4); // Seta Cursor na 1ª posição da 3ª linha
                                      // Enviando cada trecho dos valores lidos ao LCD
                                      LCD_sendstring(“PESO:  “);        // Envia uma string para detalhar a leitura
                                      LCD_sendvariavel(milhar2x);
                                      LCD_sendvariavel(centena2x);
                                      LCD_sendstring(“.”);  // Envia uma string para detalhar a leitura
                                      LCD_sendvariavel(dezena2x);
                                      LCD_sendvariavel(unidade2x);
                                      LCD_sendstring(“0”); // Envia uma string para detalhar a leitura
                                      LCD_sendstring(” (N)  “);     // Envia uma string para detalhar a leitura
                                      ADC_oe=0; // Desliga a leitura de dados
                                      tec_inicio();
                                      //teclado=0;
                                      //teclado=le_tecla();
                                      //if((teclado=le_tecla())!=0);
                                     
                                      x++;
                                      }
                                      //if (condicao < 0)
                                      else
                                      {
                                      ADC_poweron();
                            //       LCD_instruction(0x80); // Seta cursor na 1ª posição da 1ª linha
                            //       LCD_sendstring(“1:Continua Leitura”); // texto a ser enviado
                            //       LCD_instruction(0xC0); // Seta Cursor na 1ª posição da 2ª linha
                            //       LCD_sendstring(“2:TARA”); // texto a ser enviado
                                     
                                      // Código responsável por tirar uam média do valor lido para evitar discrepâncias
                                                                            
                                      //temp_digito = condicao;
                                      tempx = condicaox*(-1);
                                      //temp = temp_digito*2;
                                      temp2x = condicaox*(-9.8); // Conversão para newton e exibição correta 9,8*2
                                     
                                      // Separando o valor lido em 4 partes
                                     
                                      unidadex=tempx%10;   
                                      dezenax=(tempx%100)/10;
                                      centenax=(tempx/100)%10;
                                      milharx=tempx/1000;
                                      unidade2x=temp2x%10;   
                                      dezena2x=(temp2x%100)/10;
                                      centena2x=(temp2x/100)%10;
                                      milhar2x=temp2x/1000;
                           
                                      // Somando 0x30h para cada variavel.
                                      // 0x30h é o endereço onde começa o Número zero da tabela ASCII.
                                      // Esta parte se refere aos valores em kg (MASSA)
                                      milharx+=0x30;
                                      centenax+=0x30;
                                      dezenax+=0x30;
                                      unidadex+=0x30;
                                      // Somando 0x30h para cada variavel
                                      // Esta segunda parte se refere aos valores em Newton
                                      milhar2x+=0x30;
                                      centena2x+=0x30;
                                      dezena2x+=0x30;
                                      unidade2x+=0x30;
                                     
                                     // Enviando cada trecho dos valores lidos ao LCD                 
                                      LCD_instruction(0x94); // Seta Cursor na 1ª posição da 3ª linha
                                      LCD_sendstring(“MASSA: -“);     // Envia uma string para detalhar a leitura
                                      LCD_sendvariavel(milharx);
                                      LCD_sendvariavel(centenax);
                                      LCD_sendstring(“.”);  // Envia uma string para detalhar a leitura
                                      LCD_sendvariavel(dezenax);
                                      LCD_sendvariavel(unidadex);
                                      LCD_sendstring(“0”); // Envia uma string para detalhar a leitura
                                      LCD_sendstring(” (kg)”);     // Envia uma string para detalhar a leitura
                                      ADC_oe=0; // Desliga a leitura de dados
                                      LCD_instruction(0xD4); // Seta Cursor na 1ª posição da 3ª linha
                                      // Enviando cada trecho dos valores lidos ao LCD
                                      LCD_sendstring(“PESO:  -“);       // Envia uma string para detalhar a leitura
                                      LCD_sendvariavel(milhar2x);
                                      LCD_sendvariavel(centena2x);
                                      LCD_sendstring(“.”);  // Envia uma string para detalhar a leitura
                                      LCD_sendvariavel(dezena2x);
                                      LCD_sendvariavel(unidade2x);
                                      LCD_sendstring(“0”); // Envia uma string para detalhar a leitura
                                      LCD_sendstring(” (N)”);       // Envia uma string para detalhar a leitura
                                      ADC_oe=0; // Desliga a leitura de dados
                                     tec_inicio();
                                     
                                     
                                     
                                      x++;
                            }
                                     
                                      }
                                     
                                               break;
                                      }
                           
                                              
                   case 3: // Temporario Para teste de direcionamento
                                      {
                                     
                                      goto inicio;
                                    
                                      }
                            case 4: // Temporario Para teste de direcionamento
                                               {
                                     
                                     
                             
                                               }
                                     
                   }
        
         }
         }
        
        
        
        
void LCD_busy()
{
    unsigned char i,j;
         for(i=0;i<50;i++)
                   for(j=0;j<255;j++);
}
void LCD_poweron()
{
unsigned int i;
for (i=0;i<22500; i++);
}
void LCD_instruction(unsigned char var)
{
     LCD_data  = var;     
     LCD_rs   = 0;       
     LCD_rw   = 0;       
     LCD_en   = 1;       
          _nop_();  // Uma instrução que não faz nada só gasta 1 ciclo de máquina.
          _nop_();
     LCD_en   = 0;
     LCD_busy();         
}
/* A sequnência de instruções LCD_instruction se refere ao envio de uma
   sequência de 8 bits para o barramento de dados do LCD, essas instruções
   são tabeladas e podem ser achados no Data Sheet do LCD.
   A função acima passa as instruções para o LCD
   LCD_command(0x01); */
void LCD_sendstring(unsigned char *var)
{
     while(*var)              //Enquanto os caracteres durarem
     LCD_senddata(*var++);  //Envia os caracteres um por um
          LCD_busy();         
}
/* A função acima passa caracter por caracter
   para a função LCD_senddata
   LCD_sendstring(“LCD Tutorial”);         */
void LCD_sendvariavel(int var)
{
          LCD_data  = var;     
     LCD_rs   = 1;       
     LCD_rw   = 0;       
     LCD_en   = 1;       
          _nop_();
          _nop_();
          LCD_en   = 0;
     LCD_busy();             
}
/* A função acima passa as variáveis convertidas
   após a leitura do ADC para o LCD
   LCD_sendvariavel(centena);      */
void LCD_senddata(unsigned char var)
{
     LCD_data  = var;     
     LCD_rs   = 1;       
     LCD_rw   = 0;       
     LCD_en   = 1;       
          _nop_();
          _nop_();
          LCD_en   = 0;
     LCD_busy();         
}
/* A função acima passa caracter por caracter
o texto para o LCD. */
// ****Inicio das funções referentes ao ADC****
void ADC_poweron(void)
{
         ADC_data=0xFF; // Seta a porta P0 como INPUT
         ADC_ale=0;          // Começo do pulso LOW to HIGH
         _nop_();       // Gasta um ciclo de máquina
         ADC_start=0;   // Começo do pulso LOW to HIGH
         LCD_busy();         // Gasta tempo antes de mandar um Pulso High
         ADC_ale=1;          // Começo do pulso HIGH to LOW
         _nop_();
         ADC_start=1;   // Começo do pulso HIGH to LOW
         LCD_busy();
         ADC_ale=0;
         _nop_();
         ADC_start=0;
         LCD_busy();
         ADC_oe=1;           // Envia os dados amostrados para o uC
}
/* Para começar a ler os dados enviados pelo ADC devemos respeitar seu
   diagrama de tempo por isso os pulsos em ADC_ale e ADC_start */
// ****Inicio das funções referentes ao teclado****
void tec_inicio()
{
keyport = 0x0F;
}
/* Definimos a porta P3 (keyport) como Saida para as linhas e
   entrada para as colunas */
// Começamos agora o código para fazer a leitura do teclado
int le_tecla()
{
int i,k,tecla=0;
k=1;
         for (i=0;i<4;i++)  
                   {
                   keyport &=~(0x80>>i);
                                     
                   if (!col1)
                            {
                            tecla = k+0;
                            while(!col1);
                            return tecla;
                            }
                   if (!col2)
                            {
                            tecla = k+1;
                            while(!col2);
                            return tecla;
                            }
                           
                            if (!col3)
                            {
                            tecla = k+2;
                            while(!col3);
                            return tecla;
                            }
                            if (!col4)
                            {
                            tecla = k+3;
                            while(!col4);
                            return tecla;
                            }
                            k+=4;
                            keyport |= 0x80>>i; // Torna as linhas Altas novamente.
                   }
                            return FALSE;
}
        
        
                  

 

Posted by medigaco_wp in Sem categoria, 0 comments

Mãe Solteira constrói uma casa usando vídeos do YouTube

[vc_row][vc_column width=”1/2″][vc_column_text]Cara Brookins é uma mulher incrível. Ela é uma ótima oradora e autora  motivacional. A razão para isso é  a experiência. Qualquer um que esteja procurando a motivação para fazer algo, não deve ir mais longe do que procurar Cara. Ela e sua família provaram que tudo é possível se você tem o desejo de ter sucesso.

Quando Cara Brookins se viu em uma situação ruim, algo precisava ser feito. Ela e seus quatro filhos precisavam de um lugar para morar, mas não podiam comprar uma casa. Eles poderiam no entanto se dar ao luxo de comprar os materiais para construir sua própria casa. Então isso foi exatamente o que eles fizeram. Um grande problema, porém, é que apenas comprar os materiais não era o suficiente eles precisavam de uma  casa construída. Eles não tinham nenhuma experiência além de martelar unhas. O que eles fizeram? Bem, eles começaram a ver todos os tipos de vídeos no YouTube, é claro!

[/vc_column_text][/vc_column][vc_column width=”1/2″][vc_column_text]A família começou a aprender a fazer coisas assistindo vídeos no YouTube e cada um deles desenvolveu um determinado conjunto de habilidades para ajudar com o projeto. Todas as viagens que levaram a lojas de material de construção também incluíam perguntas e pedidos de conselhos de pessoas que encontravam nas lojas. Os resultados são surpreendentes como eles realmente construíram sua própria casa. Não é uma casa normal, porém, como você verá em poucos minutos, é uma casa de sonho que a maioria das pessoas iria querer. Eles fizeram um trabalho fantástico e eles fizeram tudo sozinhos. Nada pode bater esse sentimento!

Cara Brookins enfrentou uma situação terrível com seus quatro filhos. Ela decidiu usar o YouTube para aprender algumas coisas e os resultados são surpreendentes.[/vc_column_text][/vc_column][/vc_row]

Posted by medigaco_wp in Uncategorised, 0 comments
Construindo um contador de Visitas com um Sensor infravermelho (detector de movimento)

Construindo um contador de Visitas com um Sensor infravermelho (detector de movimento)

Radiação infravermelha
A radiação infravermelha foi descoberta em 1800 por William Herschel, um astrônomo inglês de origem alemã. Hershell colocou um termômetro de mercúrio no espectro obtido por um prisma de cristal com a finalidade de medir o calor emitido por cada cor. Descobriu que o calor era mais forte ao lado do vermelho do espectro, observando que ali não havia luz. Esta foi a primeira experiência que demonstrou que o calor pode ser captado em forma de imagem, como acontece com a luz visível.
Espectro eletromagnético de cores
Figura – 1 Espectro eletromagnético. Fonte  http://www.magnetosblog.com/efeitos-beneficio-do-infravermelho-longo acessado em 01/04/20112
Sensor infravermelho – PIR (Passive infra-red)
Sensores infravermelhos começaram a ser usados por volta de 1940, originalmente desenvolvido para aplicações militares e cientificas.
Agora a tecnologia é usada largamente em diversos produtos comerciais como alarmes de detecção de intrusos, lâmpadas acionadas automaticamente, etc.
Os sensores modernos são altamente eficientes provendo conveniência, segurança e baixo custo.
Podem ser usados em qualquer lugar onde pessoas ocasionalmente caminham como corredores, garagens, jardins etc.
Como um sensor PIR funciona
Todos os sensores PIR detectam mudanças na radiação infravermelha que é emitida na forma de calor por diversos corpos como carros, seres humanos, animais etc.
Quanto maior o corpo mais radiação infravermelha é emitida e quanto mais radiação mais fácil é a detecção de movimento.
Podemos considerar o detector de movimento como uma chave ON – OFF controlada eletronicamente, toda vez que uma fonte de calor é detectada um sinal digital é enviado a saída (no caso do sensor usado um sinal de tensão ALTO +3,3V).
sensor detector infravermelho detecção
Figura – 2 Detecção de movimento. Fonte  http://www.glolab.com/pirparts/infrared.html  acessado em 01/04/20112
Conectando seu sensor ao Arduino.

A maioria dos módulos possuem 3 pinos na PCI, o layout dos pinos pode mudar mas basicamente são Alimentação – Saída – Terra (geralmente a descrição está escrito na  placa com silkscreen).

Faça um teste rápido alimentando seu sensor antes de conectá-lo ao arduino, caso ele não esteja mostrando uma saída de tensão coerente tente utilizar um resistor de Pullup (um exemplo pode ser visto no meu artigo sobre botões https://mediga.com.br/primeiro-projeto-com-o-arduino-pisca-led/)
Sensor Infravermelho detector infravermelho arduino
Figura 3 – Vista traseira do sensor
Especificações:
  • Tensão de entrada: DC 4.5 a 20V
  • Consumo sem detecção: 50uA
  • Tensão de saída 0,3V OFF e 3,6V ON
  • Ângulo de detecção: 110 graus
  • Distância de detecção: max 7 m
Montagem do circuito
Conecte o pino – do Módulo ao GND (terra) do Arduino
Conecte o pino + do Módulo ao 5V (Vdc) do Arduino
Conecte o pino OUT do Módulo ao pino 8 do Arduino
  
Código Fonte
#define sensor 8 // Define o pino 8 como detector de nível alto do sensor de presença
#include <LiquidCrystal.h> // Bilbioteca necessaria para utilizar o LCD
/* Biblioteca com funcoes para uso de um LCD baseado no Hitachi HD 44780 */
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
/* Define os pinos de ligacao do LCD ao arduino com esta ordem LiquidCrystal(rs, enable, d4, d5, d6, d7)  */
int detecta=0;
int valor_acumulado=0;
void setup()
{
   /*lcd.begin(cols, rows) */
   lcd.begin(20, 4); /* Tipo de LCD usado no meu caso de 20 colunas por 4 linhas */
   lcd.setCursor(0, 0); /* O Cursor iniciara na coluna zero linha 0 */
   lcd.print(”    Central AVR!”);
   lcd.setCursor(0, 2); /* O Cursor iniciara na coluna zero linha 2 */
   lcd.print(“Detectados = 0”); /* Mensagem inicial indicando que nenhum movimento foi computado */
   lcd.print(” movs”);
   pinMode(sensor, INPUT); /* Define o pino 8 como entrada */
}
  void loop()
    {
      if(digitalRead(sensor)==HIGH) /* Se algum objeto for detectado executa o bloco abaixo */
     {
      valor_acumulado=detecta+1;
      lcd.setCursor(0, 2); /* O Cursor iniciara na coluna zero linha 2 */
      lcd.print(“Detectados = “);
      lcd.print(valor_acumulado); // imprime no LCD o número da detecção
      lcd.print(” movs”);
      delay(8000); //espera 8 segundos até computar a proxima detecção (meu sensor fica 7 segundos em nivel alto)
      detecta = valor_acumulado; /* Guarda valor atual para ser incrementado na próxima detecção */
     }
    }

Resultado final 

circuito de detecção movimento infravermelho arduino

 Figura 4 – Vista geral da montagem

 

 Vídeo 1 – Contador de Visitas.
Posted by medigaco_wp in Arduino, Sem categoria, 3 comments
Load more