Hola Suky...
cuales fueron los pasos para calibrar el CS5463?
he dejado un poco de lado esta parte porque estaba reviviendo un equipo ethernet que quiero conectarle a este equipo...
Además tengo otro problema, cuando pido valores consecutivos de una variable (Vrms, por ejemplo) y luego pido una variable distinta (Irms, por ejemplo) me llega el valor de la primera variable (Vrms) en vez de la que pedí (Irms). Cuando la vuelvo a pedir funciona bien, pero si cambio pasa lo mismo. Te ha pasado algo así? Hay una solución más elegante que pedir 2 veces el dato?
te adjunto el código que estoy usando
#include <18f252.h>
#fuses HS,NOWDT
#use delay(clock=20MHz)
#use spi(FORCE_HW, MODE=0, MASTER, stream=MYSPI, BAUD=400000, BITS=8)
#use rs232(baud=19200, uart1, ERRORS, stream=SERIE)
//constantes
#define INT PIN_B1
#define E1 PIN_B2
#define E3 PIN_B0
#define SIGNO PIN_B3
#define CS PIN_B4
#define RST PIN_B5
#define LED PIN_C1
//Ordenes Serie
#define LEER 'T'
//variables globales
int32 EA_consumida=0, EA_entregada=0, EA_total=0;
int32 ER_consumida=0, ER_entregada=0, ER_total=0;
int32 EA_delta=0, ER_delta=0;
int8 recibido[16];
int8 index=0;
int8 comm, param1, param2, param3;
int8 h_byte, m_byte, l_byte;
int1 error = 0;
int1 flagDebug = 0;
int1 flagProcesar = 0;
//definicion de funciones
void CS5463_init();
int32 leer_CS5463(int registro);
void sincronizar_CS5463();
int ghex(char digit1, char digit2);
//interrupciones
#INT_EXT2
void EA()
{
if(input(SIGNO))
{
EA_consumida++;
EA_total++;
EA_delta++;
}
else
{
EA_entregada++;
EA_total--;
EA_delta--;
}
}
#INT_EXT
void ER()
{
if(input(SIGNO))
{
ER_consumida++;
ER_total++;
ER_delta++;
}
else
{
ER_entregada++;
ER_total--;
ER_delta--;
}
}
#INT_RDA
void comunicacion()
{
if(kbhit(SERIE))
{
recibido[index] = toupper(fgetc(SERIE));
if (flagDebug)
{
fputc(recibido[index],SERIE); //Debug
}
if((recibido[index]!='\r')&&(recibido[index]!='\n'))
{
if(index<16)
{
index++;
}
else
{
index=0;
}
}
else if ((recibido[index]=='\n'))
{
recibido[index]='\0';
flagProcesar = 1;
index=0;
disable_interrupts(INT_RDA);
}
}
}
// Función Principal
void main()
{
output_high(LED);
delay_ms(1000);
output_low(LED);
fprintf(SERIE, "\fIniciando dispositivo...");
output_low(RST);
delay_ms(200);
output_high(RST);
delay_ms(100);
//CS5463_init();
fprintf(SERIE, "OK\r\n\r\n");
delay_ms(500);
enable_interrupts(INT_RDA);
enable_interrupts(INT_EXT);
enable_interrupts(INT_EXT2);
enable_interrupts(GLOBAL);
for(;;)
{
if(flagProcesar)
{
output_high(LED);
comm=0;
param1=0;
param2=0;
param3=0;
switch(recibido[0])
{
case 'R':
{
comm=ghex(recibido[1], recibido[2]);
if(!error)
{
output_low(CS);
spi_xfer(comm);
h_byte=spi_xfer(0xff);
m_byte=spi_xfer(0xff);
l_byte=spi_xfer(0xff);
output_high(CS);
if(flagDebug)
{
fprintf(SERIE, "LEIDO: (%X)%X%X%X\r\n", comm, h_byte, m_byte, l_byte ); //Debug
}
else
{
fputc(h_byte, SERIE);
fputc(m_byte, SERIE);
fputc(l_byte, SERIE);
}
}
else
{
error = 0;
if(flagDebug)
{
fprintf(SERIE, "ERROR EN LA SINTAXIS DEL COMANDO.\r\n"); //Debug
}
}
break;
}
case 'W':
{
comm=ghex(recibido[1], recibido[2]);
param1=ghex(recibido[3], recibido[4]);
param2=ghex(recibido[5], recibido[6]);
param3=ghex(recibido[7], recibido[8]);
if(!error)
{
output_low(CS);
spi_xfer(comm);
spi_xfer(param1);
spi_xfer(param2);
spi_xfer(param3);
output_high(CS);
if(flagDebug)
{
fprintf(SERIE, "ESCRITO: (%X)%X%X%X\r\n", comm, param1, param2, param3); //Debug
}
else
{
fputc(0x00, SERIE);
}
}
else
{
error = 0;
if(flagDebug)
{
fprintf(SERIE, "ERROR EN LA SINTAXIS DEL COMANDO.\r\n"); //Debug
}
else
{
fputc(0xff, SERIE);
}
}
break;
}
case 'I':
{
comm=ghex(recibido[1], recibido[2]);
if(!error)
{
output_low(CS);
spi_xfer(comm);
output_high(CS);
if(flagDebug)
{
fprintf(SERIE, "ENVIADO: %X\r\n", comm); //Debug
}
else
{
fputc(0x00, SERIE);
}
}
else
{
error = 0;
if(flagDebug)
{
fprintf(SERIE, "ERROR EN LA SINTAXIS DEL COMANDO.\r\n"); //Debug
}
else
{
fputc(0xff, SERIE);
}
}
break;
}
case 'S':
{
output_low(CS);
spi_xfer(0xff);
spi_xfer(0xff);
spi_xfer(0xff);
spi_xfer(0xfe);
output_high(CS);
if(flagDebug)
{
fprintf(SERIE, "SINCRONIZADO.\r\n"); //Debug
}
else
{
fputc(0x00, SERIE);
}
break;
}
case 'D':
{
if((recibido[1]=='D')&&(recibido[2]=='E')&&(recibido[3]=='B')&&(recibido[4]=='U')&&(recibido[5]=='G'))
{
flagDebug = 0;
fprintf(SERIE, "DEBUG DESACTIVADO.\r\n"); //Debug
}
else
{
if(flagDebug)
{
fprintf(SERIE, "ERROR EN LA SINTAXIS DEL COMANDO.\r\n"); //Debug
}
else
{
fputc(0xff, SERIE);
}
}
break;
}
case 'A':
{
if((recibido[1]=='D')&&(recibido[2]=='E')&&(recibido[3]=='B')&&(recibido[4]=='U')&&(recibido[5]=='G'))
{
flagDebug = 1;
fprintf(SERIE, "DEBUG ACTIVADO.\r\n"); //Debug
}
else
{
if(flagDebug)
{
fprintf(SERIE, "ERROR EN LA SINTAXIS DEL COMANDO.\r\n"); //Debug
}
else
{
fputc(0xff, SERIE);
}
}
break;
}
case 'E':
{
if(((recibido[1]=='A')||(recibido[1]=='R'))&&((recibido[2]=='C')||(recibido[2]=='E')||(recibido[2]=='T')||(recibido[2]=='D')))
{
if(recibido[1]=='A')
{
switch(recibido[2])
{
case 'C':
{
if(flagDebug)
{
fprintf(SERIE, "ENERGIA ACTIVA CONSUMIDA: %ld\r\n", EA_consumida);
}
else
{
fputc(make8(EA_consumida,3), SERIE);
fputc(make8(EA_consumida,2), SERIE);
fputc(make8(EA_consumida,1), SERIE);
fputc(make8(EA_consumida,0), SERIE);
}
break;
}
case 'E':
{
if(flagDebug)
{
fprintf(SERIE, "ENERGIA ACTIVA ENTREGADA: %ld\r\n", EA_entregada);
}
else
{
fputc(make8(EA_entregada,3), SERIE);
fputc(make8(EA_entregada,2), SERIE);
fputc(make8(EA_entregada,1), SERIE);
fputc(make8(EA_entregada,0), SERIE);
}
break;
}
case 'T':
{
if(flagDebug)
{
fprintf(SERIE, "ENERGIA ACTIVA TOTAL: %ld\r\n", EA_total);
}
else
{
fputc(make8(EA_total,3), SERIE);
fputc(make8(EA_total,2), SERIE);
fputc(make8(EA_total,1), SERIE);
fputc(make8(EA_total,0), SERIE);
}
break;
}
case 'D':
{
if(flagDebug)
{
fprintf(SERIE, "DELTA DE ENERGIA ACTIVA: %ld\r\n", EA_delta);
}
else
{
fputc(make8(EA_delta,3), SERIE);
fputc(make8(EA_delta,2), SERIE);
fputc(make8(EA_delta,1), SERIE);
fputc(make8(EA_delta,0), SERIE);
}
EA_delta = 0;
break;
}
}
}
else if(recibido[1]=='R')
{
switch(recibido[2])
{
case 'C':
{
if(flagDebug)
{
fprintf(SERIE, "ENERGIA REACTIVA CONSUMIDA: %ld\r\n", ER_consumida);
}
else
{
fputc(make8(ER_consumida,3), SERIE);
fputc(make8(ER_consumida,2), SERIE);
fputc(make8(ER_consumida,1), SERIE);
fputc(make8(ER_consumida,0), SERIE);
}
break;
}
case 'E':
{
if(flagDebug)
{
fprintf(SERIE, "ENERGIA REACTIVA ENTREGADA: %ld\r\n", ER_entregada);
}
else
{
fputc(make8(ER_entregada,3), SERIE);
fputc(make8(ER_entregada,2), SERIE);
fputc(make8(ER_entregada,1), SERIE);
fputc(make8(ER_entregada,0), SERIE);
}
break;
}
case 'T':
{
if(flagDebug)
{
fprintf(SERIE, "ENERGIA REACTIVA TOTAL: %ld\r\n", ER_total);
}
else
{
fputc(make8(ER_total,3), SERIE);
fputc(make8(ER_total,2), SERIE);
fputc(make8(ER_total,1), SERIE);
fputc(make8(ER_total,0), SERIE);
}
break;
}
case 'D':
{
if(flagDebug)
{
fprintf(SERIE, "DELTA DE ENERGIA REACTIVA: %ld\r\n", ER_delta);
}
else
{
fputc(make8(ER_delta,3), SERIE);
fputc(make8(ER_delta,2), SERIE);
fputc(make8(ER_delta,1), SERIE);
fputc(make8(ER_delta,0), SERIE);
}
ER_delta = 0;
break;
}
}
}
}
else
{
if(flagDebug)
{
fprintf(SERIE, "ERROR EN LA SINTAXIS DEL COMANDO.\r\n"); //Debug
}
else
{
fputc(0xff, SERIE);
}
}
break;
}
case 'H':
{
if((recibido[0]=='H')&&(recibido[1]=='E')&&(recibido[2]=='L')&&(recibido[3]=='P'))
{
fprintf(SERIE, "\r\n");
fprintf(SERIE, "*********************************************************\r\n");
fprintf(SERIE, "* COMANDOS *\r\n");
fprintf(SERIE, "*********************************************************\r\n");
fprintf(SERIE, "* HELP : Muestra esta ayuda. *\r\n");
fprintf(SERIE, "* IXX : Ejecuta la instruccion XX. *\r\n");
fprintf(SERIE, "* S : Sincroniza reloj SPI *\r\n");
fprintf(SERIE, "* RXX : Lee el registro XX *\r\n");
fprintf(SERIE, "* WXXYYYYYY: Escribe en el registro XX el valor YYYYYY. *\r\n");
fprintf(SERIE, "* ADEBUG : Activa DEBUG. *\r\n");
fprintf(SERIE, "* DDEBUG : Desactiva DEBUG. *\r\n");
fprintf(SERIE, "* EAC : Energia Activa Consumida. *\r\n");
fprintf(SERIE, "* EAE : Energia Activa Entregada. *\r\n");
fprintf(SERIE, "* EAT : Energia Activa Total. *\r\n");
fprintf(SERIE, "* ERC : Energia Reactiva Consumida. *\r\n");
fprintf(SERIE, "* ERE : Energia Reactiva Entregada. *\r\n");
fprintf(SERIE, "* ERT : Energia Reactiva Total. *\r\n");
fprintf(SERIE, "* EAD : Delta Energia Activa. *\r\n");
fprintf(SERIE, "* ERD : Delta Energia Reactiva. *\r\n");
fprintf(SERIE, "*********************************************************\r\n");
fprintf(SERIE, " NOTA1: XX es un numero hexadecimal de 2 cifras.\r\n");
fprintf(SERIE, " NOTA2: YYYYYY es un numero hexadecimal de 6 cifras.\r\n");
fprintf(SERIE, "\r\n");
}
else
{
if(flagDebug)
{
fprintf(SERIE, "ERROR EN LA SINTAXIS DEL COMANDO.\r\n"); //Debug
}
else
{
fputc(0xff, SERIE);
}
}
break;
}
default:
{
if(flagDebug)
{
fprintf(SERIE, "COMANDO NO VALIDO.\r\n"); //Debug
}
else
{
fputc(0xff, SERIE);
}
}
}
flagProcesar = 0;
enable_interrupts(INT_RDA);
output_low(LED);
}
}
}
void CS5463_init()
{
// Software reset
output_low(CS);
spi_xfer(0x80);
output_high(CS);
delay_ms(200);
//Registro de configuración: Int activo bajo; HPF=1, K=1
output_low(CS);
spi_xfer(0x40);
spi_xfer(0x00);
spi_xfer(0x00);
spi_xfer(0x00);
output_high(CS);
//N=4000 cristal de 4,096MHz
output_low(CS);
spi_xfer(0x4A);
spi_xfer(0x00);
spi_xfer(0x0F);
spi_xfer(0xA0);
output_high(CS);
// Borrar todos los bits de STATUS
output_low(CS);
spi_xfer(0x5E);
spi_xfer(0x80);
spi_xfer(0x00);
spi_xfer(0x01);
output_high(CS);
// Mask=0x000000 -> INT=DRDY Ciclo de computado terminado
output_low(CS);
spi_xfer(0x74);
spi_xfer(0x00);
spi_xfer(0x00);
spi_xfer(0x00);
output_high(CS);
//Conversión contínua
output_low(CS);
spi_xfer(0xE8);
output_high(CS);
}
int32 leer_CS5463(int registro)
{
int h_byte, m_byte, l_byte;
output_low(CS);
spi_xfer(registro<<1);
h_byte=spi_xfer(0xff);
m_byte=spi_xfer(0xff);
l_byte=spi_xfer(0xff);
output_high(CS);
return(make32(0,h_byte,m_byte,l_byte));
}
void sincronizar_CS5463()
{
output_low(CS);
spi_xfer(0xff);
spi_xfer(0xff);
spi_xfer(0xff);
spi_xfer(0xff);
spi_xfer(0xfe);
output_high(CS);
}
int ghex(char digit1, char digit2)
{
int8 temp_int1, temp_int2;
int8 respuesta=0xff;
if(((digit1>='0' && digit1<='9')||(digit1>='A' && digit1<='F'))&&((digit2>='0' && digit2<='9')||(digit2>='A' && digit2<='F')))
{
if(digit1<='9')
temp_int1 = digit1-'0';
else
temp_int1 = (digit1-'A')+10;
if(digit2<='9')
temp_int2 = digit2-'0';
else
temp_int2 = (digit2-'A')+10;
respuesta = (temp_int1<<4)+temp_int2;
}
else
{
error=1;
if(flagDebug)
{
fprintf(SERIE, "ERROR EN LA ENTRADA %c%c.\r\n", digit1, digit2); //Debug
}
}
return(respuesta);
}