Autor Tema: (Solucionado) Ayuda con SPI y CS5463 (Leído 22447 veces)

bolso103 · « **Respuesta #15 en:** 26 de Agosto de 2011, 14:06:44 »

El problema estaba en la medición. Al enchufar el osciloscopio con un cable de 3 patas, no se estaba referenciando contra el vivo. Ahora aparecen formas de onda aceptables.

Con respecto al Cirrus, conecté las entradas diferenciales como corresponde, VA+ a la salida del rectificador, y ACGDN es la tierra, conectada al vivo. Conecté la punta del osciloscopio a E1 para ver si aparecían los pulsos de energía con la frecuencia proporcional a la potencia...pero no. Solo observo ruido...

Suky · « **Respuesta #16 en:** 26 de Agosto de 2011, 14:49:02 »

Cita de: bolso103 en 26 de Agosto de 2011, 14:06:44

El problema estaba en la medición. Al enchufar el osciloscopio con un cable de 3 patas, no se estaba referenciando contra el vivo. Ahora aparecen formas de onda aceptables.

Con respecto al Cirrus, conecté las entradas diferenciales como corresponde, VA+ a la salida del rectificador, y ACGDN es la tierra, conectada al vivo. Conecté la punta del osciloscopio a E1 para ver si aparecían los pulsos de energía con la frecuencia proporcional a la potencia...pero no. Solo observo ruido...

Pero lo inicializaste? Hay que indicarle por SPI, conversión continua o conversión única.

Saludos!

bolso103 · « **Respuesta #17 en:** 26 de Agosto de 2011, 17:10:01 »

Aún no tenemos pronto el sócalo para el MCU, estará listo el lunes. ¿Será que por defecto hace una única conversión , y por eso no se observaron pulsos en E1?

Gracias Suky, como siempre.
Gabriel

Suky · « **Respuesta #18 en:** 26 de Agosto de 2011, 17:43:43 »

Cita de: bolso103 en 26 de Agosto de 2011, 17:10:01

Aún no tenemos pronto el sócalo para el MCU, estará listo el lunes. ¿Será que por defecto hace una única conversión , y por eso no se observaron pulsos en E1?

Gracias Suky, como siempre.
Gabriel

No, no hace nada. Porque hay varios parámetros que ajustar y luego iniciar conversiones.

Saludos!

bolso103

Hola Suky,

Desde el lunes que me estoy tratando de comunicar con el cirrus. Ayer encontré un programa llamado SPIGen que utiliza el puerto paralelo del PC. Lo que hace es simplemente comunicarse por SPI hacia algun dispositivo que tenga SPI. O sea, leer y escribir. Cuando se hace un comando de lectura, el PC muestra el valor del registro del dispositivo externo.
Ayer estuve probando dialogar (sin conectar las entradas diferenciales, sólo la fuente de 5v) y nunca tuve respuesta del cirrus. Entonces hoy hice lo mismo, pero con las entradas conectadas.

En el momento de enchufar, comenzó a salir humo por el puerto paralelo. Puede haber sido un desbalance de tierras, porque no uní las tierras del cirrus con la del paralelo. También puede haber sido un desbalance producido por el osciloscopio, que estaba conectado a SCLK.

Tienes idea que puede haber sucedido?

Seguramente compre un adaptador SSOP24 a DIP 24, para trabajar con el chip más tranquilo. Y comenzaré desde cero, porque cosas como estan no pueden suceder. Algo así sería: http://www.ebay.com/itm/TSSOP24-SSOP24-SSOP-DIP24-Adapter-Universal-Xeltek-/220844857550?pt=LH_DefaultDomain_0&hash=item336b6118ce

Un abrazo,
Gabriel

Suky

No conectar las tierra fue una posible causa, y siendo el puerto paralelo muy sensible, dudo que esté en condiciones

Aparte de la tensión de 5V, colocaste algún oscilador o cristal?

Cita de: bolso103 en 08 de Septiembre de 2011, 18:23:51

Seguramente compre un adaptador SSOP24 a DIP 24, para trabajar con el chip más tranquilo. Y comenzaré desde cero, porque cosas como estan no pueden suceder. Algo así sería: http://www.ebay.com/itm/TSSOP24-SSOP24-SSOP-DIP24-Adapter-Universal-Xeltek-/220844857550?pt=LH_DefaultDomain_0&hash=item336b6118ce

Interesante adaptador! No había visto de ese estilo

Saludos!

MGLSOFT

Lindo adaptador!!
A ese precio ya no te conviene comprar el medidor hecho??

cyberpex

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

Código: [Seleccionar]

#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);
}

cyberpex

El código anterior es el que utilizo para optoacoplar el medidor al controlador principal.
se comunica por serie (con optoacopladores) y un PIC18F252 hace la interfaz SPI, además de contar los pulsos de energía activa y reactiva.

Este micro recibe las ordenes en texto plano:

IXX: Escribe la instrucción XX (ejm: I80)
RXX: Lee el registro XX (ejm: R26 lee y devuelve 3 bytes de Temperatura)
WXXYYYYYY: Escribe el registro XX con los datos YYYYYY)
S: Sincroniza el reloj SPI (FFFFFFFE)

eso, la magia la hace la otra plca, inicio y configuración

Suky

En este mensaje deje como realizo la lectura de los registro: http://www.todopic.com.ar/foros/index.php?topic=35036.msg292486#msg292486

nunca me ha dado el problema que comentas.

Respecto a la calibración, los pasos idénticos que indica el datasheet.

Saludos!

medidort

Hola
Estoy tratando de construir un medidor de energia con un PIC 16F690 y un CS5463 utilizando Mplab con HiTech.
Tengo un par de dudas.
Como configuran el SPI. Yo lo estoy configurando al pic como maestro y al cirrus como esclavo. El reloj del cirrus es de 4.096MHz y el del 16F690 es de 4MHz.
Tambien tengo dudas de que asignarle al CKE y al CKP dado que la hoja del cirrus no dice nada. Alguien lo sabe?
Tengo conectado los chips de la siguiente manera.
PIC16F609 ----- CS5463
RC2 ------------> CS
SDO -------------> SDI
SDI <------------- SDO
SCK ---------------> SCK

Hay que hacer algo mas como conectar resistencias de pull up u alguna otra cosa.

Tambien tengo dudas en los pedidos al cirrus; alguien sabe efectivamente como se hacen las preguntas al CS5463?
Yo estoy pidiendo de la siguiente manera. Esta bien? Si esta mal me podrían decir como lo hacen?

void CIRRUS_readVoltage(void){
   CS = 0;
   SPI_write(0x18);
   datoH = SPI_read();
   SPI_write(0xFF);
   datoM = SPI_read();
   SPI_write(0xFF);
   datoL = SPI_read();
   SPI_write(0xFF);
   CS= 1;
}

Las funciones de spi las hice yo leyendo la hoja datos pues no encontré en HiTech librerías para SPI ni para delay. Si alguien las tiene agradeceria que me las pasaran o me dijeran donde.

void SPI_write(char data){
   SSPBUF = data;
}

char SPI_read(void){
   char data;

   while(!BF){}
   data = SSPBUF;
   return data;
}

void configuracionPuertos(void){
   //PARA SPI
   //1 INPUT / 0 OUTPUT
   //Todo como salida menos el RA0
   TRISA = 0b00100001;
   PORTA = 0x00;
   //PORTB todo como salida
   //SCK (Master mode) must have TRISB<6> bit   cleared
   TRISB = 0b00110000; //RB6-SCK out
   PORTB = 0x00; //APAGADO
   //PORTC, los dos primeros son para la USART
   //SDO must have TRISC<7> bit cleared
   //SS must have TRISC<6> bit set
   TRISC = 0b01000000;
   PORTC = 0x00;
}

void configuracionInterrupciones(void){
   //------PIE1 Bits REGISTRO DE HABILITACION------
   ADIE = 0; //DesHabilito Interrupcion del A/D
   RCIE = 0;    //DesHabilito Interrupcion en la USART
   TXIE = 0; //Deshabilito Interrupcion en la USART
   SSPIE = 0; //DesHabilito Interrupcion en la SPI
   CCP1IE = 0; //Deshabilito la interrupcion del comparador
   TMR2IE = 0; //DesHabilito Interrupcion TIMER2
   TMR1IE = 0; //DesHabilito Interrupcion TIMER1

   //------PIE2 Bits REGISTRO DE HABILITACION------
   EEIE=0;
   OSFIE = 0;
   C2IE= 0;
   C1IE = 0;

   //---------INTCON Bits REGISTRO DE HABILITACION------
   GIE = 0;    //Interrupciones Globales
   PEIE = 0;    //Interrupciones Externas
   //T0IE = 0; //Termino el Timer 0
   //INTE = 0; //Cambio en la pata RB0
    //RABIE = 0; //Cambio en el puerto B
}

void configuracionSPI(void){

   //---------SSPCON: SYNC SERIAL PORT CONTROL REGISTER--------------
   SSPCON = 0b00100000;
   SSPSTAT = 0b10000000;
   SSPEN = 1


}

Desde ya muchas gracias a todos y felices fiestas

Suky

Lee el siguiente mensaje en detenimiento, mucho de lo que preguntas está allí: http://www.todopic.com.ar/foros/index.php?topic=35036.msg292486#msg292486

Sobre como conectar SPI, la única linea que puede llegar a llevar una resistencia pull-up es CS.

Saludos!

medidort

Hola
Leí como me recomendaste nuevamente tu post, ya lo había hecho.
Lo único que no me queda claro es como haces el pedido al CS5463.
Según lo que he leído se debería escribir el comando y luego leer dato, escribir FF, leer dato, escribir FF , leer dato y escribir FF.
Esto es asi?

Que hiciste con la pata PFMON del chip?

Desde ya muchas gracias y feliz año nuevo

Suky

Cita de: medidort en 30 de Diciembre de 2011, 08:26:41

Hola
Leí como me recomendaste nuevamente tu post, ya lo había hecho.
Lo único que no me queda claro es como haces el pedido al CS5463.
Según lo que he leído se debería escribir el comando y luego leer dato, escribir FF, leer dato, escribir FF , leer dato y escribir FF.
Esto es asi?

Deberías leer sobre el protocolo SPI, es full-duplex, o sea mientras envías puedes recibir al mismo tiempo. Entonces envías el comando, y mientras lees envías 0xFF por especificación de datasheet. Las funciones para trabajar con SPI entre C30 y CCS son muy distintas, entonces aprende a trabajarlo en el lenguaje que usas

Para FPMON podes leer el datasheet, allí explica como funciona y a partir de ellos podes armar un divisor resistivo para que trabaje. Sino a 5 V y listo.

Saludos!

medidort

Gracias por todo. La datasheet del CS5463 no dice claramente como hacer los pedidos.
Ahora no me imagino como enviar y recibir al mismo tiempo con el SPI siendo que tiene un solo registro para mandar y enviar el SSPBUF.
Haces algún control entre la lectura y la escritura? dejas pasar algún tiempo?
Gracias

TODOPIC

Autor Tema: (Solucionado) Ayuda con SPI y CS5463 (Leído 22447 veces)

bolso103

Re: (Solucionado) Ayuda con SPI y CS5463

Suky

Re: (Solucionado) Ayuda con SPI y CS5463

bolso103

Re: (Solucionado) Ayuda con SPI y CS5463

Suky

Re: (Solucionado) Ayuda con SPI y CS5463

bolso103

Re: (Solucionado) Ayuda con SPI y CS5463

Suky

Re: (Solucionado) Ayuda con SPI y CS5463

MGLSOFT

Re: (Solucionado) Ayuda con SPI y CS5463

cyberpex

Re: (Solucionado) Ayuda con SPI y CS5463

cyberpex

Re: (Solucionado) Ayuda con SPI y CS5463

Suky

Re: (Solucionado) Ayuda con SPI y CS5463

medidort

Ayuda con SPI y CS5463

Suky

Re: (Solucionado) Ayuda con SPI y CS5463

medidort

Re: (Solucionado) Ayuda con SPI y CS5463

Suky

Re: (Solucionado) Ayuda con SPI y CS5463

medidort

Re: (Solucionado) Ayuda con SPI y CS5463