adc0832 - alguem conhece ?

[j-menezes]

Alguem aqui tem algum link de preferencia em portugues

que explique o funcionamento deste AD ?

e se tiver algum exemplo em linguagem C ira' ajudar ainda mais


valeu


[]'s

[brasilma]

É da TEXAS ou NATIONAL?

[j-menezes]

É da TEXAS ou NATIONAL?

E' da NATIONAL

[rebelk]

foi criada no keil

colocar resistores para o up ( neste caso );



// ADC0832 lcd 2 linhas 16 colunas 16/2

#include <at898252.h>
#include <intrins.h>
#include <binario.h>
#include <delay_ms.h>
#include <delay_us.h>

#define ckl P0_0
#define cs P0_1
#define input P0_2 // =di controle do ad
#define output P0_3 // =do


#define clok_lcd P2_2
#define dado_lcd P2_1 // controle do lcd
#define dado_reset P2_0

// bit b2=0;

// *********************************************************************************************
// *********************************************************************************************
us_atraso() // 5us
{
_nop_ ();
_nop_ ();
_nop_ ();
_nop_ ();
_nop_ ();

}
/* ********************************************************************************************* */
/* ********************************************************************************************* */
pulso()
{
ckl=1;
us_atraso();
ckl=0;
us_atraso();
}

// *********************************************************************************************
// *********************************************************************************************
unsigned char ler_canal_1()
{
unsigned char valor=0,cont=0;

cs=0; // habilita o ad
us_atraso();

input=1; // start bit
pulso(); //

pulso(); // modo comum

input=0; // canal 1
pulso(); //

for ( cont = 0; cont < 8; cont++ )
{
pulso();
}
us_atraso();
for ( cont = 0; cont < 8; cont++ )
{
valor >>= 1;
if (output) valor |= b10000000;
pulso();
}

us_atraso();
cs=1;
input=1;
output=1;
return(valor);

}
/* ****************************************************************************************** */
/* ****************************************************************************************** */

unsigned char ler_canal_2()
{
unsigned char valor=0,cont=0;
cs=0; // habilita o ad
input=1; // start bit
pulso(); //

pulso(); // modo comum

pulso(); // canal 2

for ( cont = 0; cont < 8; cont++ )
{
pulso();
}
us_atraso();
for ( cont = 0; cont < 8; cont++ )
{
valor >>= 1;
if (output) valor |= b10000000;
pulso();
}

us_atraso();
cs=1;
input=1;
output=1;
return(valor);

}


/* ******************************************************************************************* */
/* ******************************************************************************************* */
pulso_1()
{
clok_lcd = 1;
_nop_ ();
_nop_ ();
clok_lcd = 0;
_nop_ ();
_nop_ ();

}
/* ********************************************************************************************* */
/* ********************************************************************************************* */
/* função que escreve no lcd a tres fio */

escreve( char bayt_lcd, char d_s )
{
unsigned char n_vezes = 0;
for ( n_vezes = 0; n_vezes < 8; n_vezes++ )
{
dado_lcd = ((bayt_lcd & b10000000) >> 7);
pulso_1();
bayt_lcd <<= 1;
}
if (d_s==0) dado_lcd=0;
else dado_lcd=1;
pulso_1();
delay_us(500);
if(!dado_reset)
{
while(dado_reset==0)
{
pulso_1();
}
}
dado_lcd=0;

}

// **********************************************************************
// **********************************************************************

reset()
{
if(!dado_reset)
{
while(dado_reset==0)
{
pulso_1();

}
}
}
// ************************************************************************
// ************************************************************************
// função de inicialização de lcd

inicializa()
{
escreve(0x38,0); // display de 2 linhas
escreve(0x06,0); // escreve deslocando cursor para direita
escreve(0x0e,0);
escreve(0x0c,0);
escreve(0x1c,0);

}
// *****************************************************************************************
// *****************************************************************************************
// função que limpa o lcd */

limpa()
{
escreve( 0x01,0 );
}

/* ******************************************************************************************* */
/* ******************************************************************************************** */
/* função que ler o dado e escreve no lcd */
ler_caractere( char *c )
{
for ( ; *c!=0; c++) escreve( *c,1 );
}

/* ******************************************************************************************* */
/* ********************************************************************************************* */
/* função que manda o cursor para a 1º coluna da 1º linha */
salta_linha1()
{
escreve(0x80,0);
}

/* ******************************************************************************************* */
/* ********************************************************************************************* */
/* função que manda o cursor para a 1º coluna da 2º linha */
salta_linha2()
{
escreve(0xc0,0);
}

/******************************************************************************************************/
/******************************************************************************************************/
unsigned int vunidade(unsigned int unidade)
{
unsigned int restund;
return restund=(unidade%10);
}

/********************************************************************************************************/
/********************************************************************************************************/
unsigned int vdezena(unsigned int dezena)
{
unsigned int restdz;
return restdz=(dezena/10) % 10;
}

/********************************************************************************************************/
/********************************************************************************************************/
unsigned int vcentena(unsigned long int centena)
{
unsigned int restct;
restct=((centena/10)/10);
return restct=restct % 10;
}

/********************************************************************************************************/
/********************************************************************************************************/
unsigned int vmilhar(unsigned int milhar)
{
unsigned int restmt;
restmt=(((milhar/10)/10)/10);
return restmt=restmt % 10;
}

/********************************************************************************************************/
/********************************************************************************************************/
unsigned int vdmilhar(unsigned int dmilhar)
{
unsigned int restdmt;
restdmt=((((dmilhar/10)/10)/10)/10);
return restdmt=restdmt % 10;
}
/********************************************************************************************************/
/********************************************************************************************************/
converte_1(unsigned int porcento_0)
{
unsigned int a;
unsigned char unidade,dezena,centena,milhar,d_milhar;
a=porcento_0;
unidade=vunidade(porcento_0);
escreve(0xce,0);
escreve((unidade + 0x30),1);

porcento_0=a;
dezena=vdezena(porcento_0);
escreve(0xcd,0);
escreve((dezena + 0x30),1);

porcento_0=a;
centena=vcentena(porcento_0);
escreve(0xcc,0);
escreve((centena + 0x30),1);

porcento_0=a;
milhar=vmilhar(porcento_0);
escreve(0xcb,0);
escreve((milhar + 0x30),1);

porcento_0=a;
d_milhar=vdmilhar(porcento_0);
escreve(0xca,0);
escreve((d_milhar + 0x30),1);

}
/*********************************************************************/
/*********************************************************************/
converte_2(unsigned int porcento_0)
{
unsigned int a;
unsigned char unidade,dezena,centena,milhar,d_milhar;
a=porcento_0;
unidade=vunidade(porcento_0);
escreve(0xc4,0);
escreve((unidade + 0x30),1);

porcento_0=a;
dezena=vdezena(porcento_0);
escreve(0xc3,0);
escreve((dezena + 0x30),1);

porcento_0=a;
centena=vcentena(porcento_0);
escreve(0xc2,0);
escreve((centena + 0x30),1);

porcento_0=a;
milhar=vmilhar(porcento_0);
escreve(0xc1,0);
escreve((milhar + 0x30),1);

porcento_0=a;
d_milhar=vdmilhar(porcento_0);
escreve(0xc0,0);
escreve((d_milhar + 0x30),1);

}
// *********************************************************************
// *********************************************************************
main()
{
TMOD=0x11;
dado_reset=1;
dado_lcd=0; // sempre zerar o ( clok e o dado) do lcd aqui neste ponto
clok_lcd=0;
reset(); // da um reset na placa do lcd

P3=0;
P2=0;

ckl=0;
cs=1; // desabilita o ad
input=1;
output=1;

delay_us(10000);
inicializa();
limpa();

salta_linha1();
ler_caractere(" adc0832 ");
salta_linha2();
while(1)
{
converte_1(ler_canal_1());
converte_2(ler_canal_2());
P3=ler_canal_1();
delay_ms(5);
}





}

[rebelk]

esta faz a mesma coisa , só que com tres pinos

adc0832.h

// ADC0832

#include <intrins.h>
#include <binario.h>


#ifndef ckl
#define ckl P1_0 // se estes pinos não estiverem definidos no
#endif // progama principal serão definidos este pinos
// como padrão


#ifndef cs
#define cs P1_1
#endif

#ifndef input_output
#define input_output P1_2 // o pino DI e DO do adc0832 estão jumpeados ( juntos )
#endif



// ********************************************************************************************
// ********************************************************************************************
us_atraso() // 5us
{
_nop_ ();
_nop_ ();
_nop_ ();
_nop_ ();
_nop_ ();

}
// *********************************************************************************************
// *********************************************************************************************
pulso()
{
ckl=1;
us_atraso();
ckl=0;
us_atraso();
}

// *********************************************************************************************
// *********************************************************************************************
unsigned char ler_canal_1()
{
unsigned char valor=0,cont=0;

cs=0; // habilita o ad
input_output=1; // start bit
us_atraso();
pulso(); //
pulso(); // modo comum
input_output=0; // canal 1
pulso(); //
input_output=1;
us_atraso();
for ( cont = 0; cont < 8; cont++ )
{
pulso();
}
us_atraso();
for ( cont = 0; cont < 8; cont++ )
{
valor >>= 1;
if (input_output) valor |= b10000000;
pulso();
}

us_atraso();
cs=1;
input_output=1;
return(valor);

}

// ******************************************************************************************
// ******************************************************************************************
unsigned char ler_canal_2()
{
unsigned char valor=0,cont=0;
cs=0; // habilita o ad
input_output=1; // start bit
pulso(); //
pulso(); // modo comum
pulso(); // canal 2
input_output=1;
us_atraso();
for ( cont = 0; cont < 8; cont++ )
{
pulso();
}
us_atraso();
for ( cont = 0; cont < 8; cont++ )
{
valor >>= 1;
if (input_output) valor |= b10000000;
pulso();
}

us_atraso();
cs=1;
input_output=1;
return(valor);
}

// ex; a=ler_canal_1();
// ex; b=ler_canal_2();