SoloCodigo

Hola, tengo el siguiente problema, digamos que a apartir de un AnsiString, lo convierto a double y muestro dos decimales.

El problema viene cuando ese ansiString supera el valor 999,99, pues en los miles pone 1.000,99 y cuando hay un punto falla la linea de código que tengo puesta:

Como podría evitar esto?

Muchas gracias y un saludo!

Hola a todos, os comento mi duda.

Resulta que tengo creada una base de datos con access (la conexión me funciona perfectamente).

El caso es que me gustaría crear una especie de rejilla (no se si con un DBGrid podría hacerse).

La idea es coger de una de las tablas las imágenes de unos productos y mostrarlos como si fuera una matriz (no uno debajo de otro como sería en una tabla).

El objetivo de esto es que al iniciar el programa lea los productos que hay y cargue las imágenes de forma automática, de tal forma si hay que realizar cambios en la base de datos, se actualice automáticamente en el programa.

No se si me he explicado bien, pero mi duda sería si ésto se podría hacer y como podría hacerse, porque no tengo claro por donde empezar.

Cualquier duda estaré encantado de resolverla.

Muchas gracias a todos, un saludo!

Hola a todos, resulta que se me ha ocurrido crear en mi aplicación un número determinado de botones (y posicionarlos correctamente) en función del número de elementos que haya en una base de datos (la conexión me funciona).

Como siempre he creado el boton arrastrándolo de la tool palette, ahora me surge la duda de si se podría crear por código.

¿Alguien lo sabe? ¿Cómo se haría?


un saludo!

Hola a todos, os pongo en situación:

Resulta que quiero pasar un int a un array de char para enviar por una trama, me explico:

Si el int <256

michar[0]=0x00;
michar[1]= (char)miint;

ahora viene el problema, cuando el int>=256, ya que me gustaria hacer lo siguiente:

si por ejemplo tengo que el int es 256, sabemos que en hexadecimal es 0x0100, por lo que yo quiero poner:

michar[0]=0x01; parte alta
michar[1]=0x00; parte baja

Veo que es algo sencillo pero no me aclaro, me podeis echar una ayudita?

Muchas gracias!

Hola de nuevo, perdona mi insistencia, pero no comprendo como tengo que hacerlo.

He probado con el siguiente código:

             

  strSQL = "DELETE FROM Tarjeta"
                strSQL = strSQL & " WHERE Tarjeta.EstadoID=" & "" & micadena1 & "" & ";"

                db.Execute strSQL, dbFailOnError
                strSQL = "COMMIT;"
                db.Execute strSQL, dbFailOnError

pero me da error en el commit.

También he probado con un START TRANSACTION  y con un BEGIN WORK  al principio y tampoco me funciona.

¿Me podrías indicar, si no es mucha molesta, como tendría que ponerlo en mi código?

Un saludo y muchas gracias

Hola, os presento mi problema.

Tengo un programa que cuando selecciono a través de un combobox la opción de bloqueada, lo que hago es copiar el registro a otra tabla (tarjetabloqueada) y posteriormente lo elimino de la tabla actual (tarjeta). El caso es que el código funciona perfectamente, lo que pasa es que cuando hago esto, me aperece en el registro movido #Eliminado (en todos los textbox que hacian referencia a ese registro).

Si salgo de mi formulario y vuelvo a entrar, la tabla se actualiza, pero en el momento en el que ejecuto la instrucción, si permanzco en él, sigue apareciendo.

Sé que se solucionaría actualizando la tabla, pues cuando cierro el formulario me voy a la tabla y le doy al boton de actualizar de access, desaparece.

Estoy programando en VBA 6.0 para una BBDD de Access 2007:

Muchas gracias, espero vuestra contestación

Hola gente!, me acabo de bajar MicroOLAP DAC for MySQL para C++ Builder 2010.
Mi objetivo es trabajar con BD en MySQL con C++ Builder, pero no tengo ni idea de como empezar.

Al principio intenté seguir los pasos indicados por LaChayra desde:
h**p://w**.youtube.com/watch?v=F-cMLrNV-tA

Pero me di cuenta que al usar el connector implicaba virtualizar un servidor y esto es incomodo de cara a una aplicacion final instalable.

Buscando un poco mas encontre MicroOLAP DAC for MySQL que por lo visto simplifica bastante el uso de BD con MySQL.

Una vez instalado he visto como se me ha añadido correctamente las pestañas nuevas.

El caso es que como soy muy novato en el tema, no tengo muy claro por donde empezar... (echo en falta un tutorial o alguien que me guie porque no paro de dar rodeos, ).

Mi pregunta es para alguien que haya trabajado con BD de MySQL en C++ Builder y que teniendo presente estos requisitos sepa guiarme:

REQUISITOS:
--------------
La aplicacion final tiene que instalarse por mediacion de un instalador (como InnoSetup) e intentar incorporar todo lo necesario para que funcione.

DUDAS:
--------

Despues de lo comentado,

1.- ¿Seria interesante trabajar con MicroOLAP DAC for MySQL para C++ Builder 2010 o mejor con el ODBC Connector tal como mostre en el link?

También tengo instalado el MySQL Workbench 5.2 CE con el que edito y modifico las tabla que quiero.

2.- En el caso de usar la opcion de MicroOLAP, ¿como se le indica que quiero que trabaje con la BD que he creado con el Workbench? ¿Podría exportarse la BD aun archivo con una extension determinada e indicarle al MicroOLAP que trabaje con ella? ¿Como se haria?

Agradezco cualquier aporte pues ando muy perdido y liado con tanta informacion pero sin saber por donde tirar.

Muchas gracias de antemano y un saludo!

Gracias a ambos por las respuestas.

El motivo por el cual me decanté por MySQL es porque veo que un lenguaje estandar muy potente e introducirlo en mi aplicación podría ser interesante de cara a un futuro para hacer enlaces con bases de datos mas complejas.

Te recomiendo que uses MySQL, pero no hace falta virtualizar nada. Usa los componentes ADO y para la conexión usa el ultimo ODBC de MySQL.

Busca información sobre cadenas de conexion de TADOConnection y MySQL. Esto te permite trabajar con una base de datos ubicada en un servidor web y acceder a los datos desde cualquier parte del mundo.

Con respecto a esto, quiero destacar que de momento únicamente quiero acceder a una base de datos ubicada en el mismo pc en donde se va a ejecutar mi aplicación, motivo por el cual esté interesado en que una vez esté desarrollada la aplicación, poder instalar todo lo necesario con un instalador.

¿Podrías darme un poco más de detalles sobre los componentes ADO? Es que no termino de comprender tu información (soy novato en esto). Si puedes citar algun ejemplo de código o un enlace donde entre en mas detalle lo agradeceria mucho.

Un saludo!

Hola a todos, antes de nada os comentaré la situación.

Estamos desarrollando un proyecto en el cual se van a comunicar diferentes PICs por un bus único, escogiendo como lenguaje el I2C y el compilador CCS.
La idea es que habrá un PIC que actuará de Maestro y gestionará la recopilación de datos de los otros microcontroladores. A este PIC lo llamaremos CEREBRO y será un PIC18F2550.

Así, que de forma ideal tendríamos un árbol en el que arriba del todo estaría CEREBRO y en las ramificaciones los diferentes PICs esclavos. Es por ello que toda comunicación debe pasar por CEREBRO.

Pues bien, existen una serie de microcontroladores que no pueden actuar como esclavos y únicamente pueden ser maestros, como el caso del módulo GSM y posiblemente WIFI (aún no se ha escogido el módulo definitivo y ambos no son de MICROCHIP).

El primer problema que se presenta es que se rompe con la filosofia que habia planteado, por lo que necesitaria implementar la función MULTI_MASTER en la cual en determinadas situaciones un PIC puede ser MAESTRO y en otras ESCLAVO.

Después de realizar numerosas pruebas simplificando el problema y comprobando que todas son exitosas (Comunicación entre un maestro y un esclavo; un maestro y dos esclavos) tanto en la lectura como en la escritura en un esclavo. Se ha procedido a la simplificación del problema.


-   Para el primer caso se ha realizado la siguiente configuración:

GSM (MASTER) -> PIC ATMEL ARQUITECTURA ARM (identificador 0x51)
CEREBRO (MULTI_MASTER)-> PIC18f2550 (direccion esclava 0x20)

implementando la función:
#use i2c(MULTI_MASTER, sda=PIN_B0, scl=PIN_B1,SLOW, force_hw, stream=I2C)

Lo único que se ha hecho es que cuando se inicializa GSM, éste comunica por I2C a cerebro que ha arrancado, enviando en HEX (0x20 0x51 0xEE 0x0D 0x0A). Pues cuando implemento en el use i2c el modo MULTI_MASTER, cerebro no responde (si se configura como esclavo y omitiendo las funciones   void i2c_init(void);   int8 i2c_mm_start(int8);   void i2c_mm_stop(void); si que funciona)

Para ello nos hemos apoyado del siguiente enlace implementando las funciones citadas.
h t t p : // w w w . c c s i n f o . c o m / f o r u m / v i e w t o p i c . p h p ? t = 4 2 6 2 6 & h i g h l i g h t = m u l t i m a s t e r
(Solucion propuesta por Wayne_)


/////////////////////////////////////////////////////////////////////////
MAIN.H
/////////////////////////////////////////////////////////////////////////

#include <18F2550.h>

#device adc=10

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES WDT128                   //Watch Dog Timer uses 1:128 Postscale
#FUSES HSPLL                    //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES NOPROTECT                //Code not protected from reading
#FUSES BROWNOUT               //No brownout reset
#FUSES BORV20                   //Brownout reset at 2.0V
#FUSES PUT                      //Power Up Timer
#FUSES NOCPD                    //No EE protection
#FUSES STVREN                   //Stack full/underflow will cause reset
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOWRT                    //Program memory not write protected
#FUSES NOWRTD                   //Data EEPROM not write protected
#FUSES IESO                     //Internal External Switch Over mode enabled
#FUSES FCMEN                    //Fail-safe clock monitor enabled
#FUSES PBADEN                   //PORTB pins are configured as analog input channels on RESET
#FUSES NOWRTC                   //configuration not registers write protected
#FUSES NOWRTB                   //Boot block not write protected
#FUSES NOEBTR                   //Memory not protected from table reads
#FUSES NOEBTRB                  //Boot block not protected from table reads
#FUSES NOCPB                    //No Boot Block code protection
#FUSES NOMCLR                   //No Master Clear pin enabled
#FUSES LPT1OSC                  //Timer1 configured for low-power operation
#FUSES NOXINST                  //Extended set extension and Indexed Addressing mode disabled (Legacy mode)
#FUSES PLL5                     //Divide By 12(48MHz oscillator input)
#FUSES CPUDIV1                  //System Clock by 4

//Configuracion de los registros
#BYTE SSPADD = 0xFC8
#BYTE SSPCON1 = 0xFC6
#BYTE SSPCON2 = 0xFC5

// Desactivamos el USB para poder usar los pines C4 y C5 como entradas digitales
#FUSES NOUSBDIV
#FUSES NOVREGEN
#BYTE UCON = 0xF6D
#BYTE UCFG = 0xF6F  
#use delay(clock=48000000)

//==============================================================================
//-----------------------  DEFINICIONES  ---------------------------------------
//==============================================================================

#define enciende  OUTPUT_HIGH
#define apaga     OUTPUT_LOW

#define PWR_IND   PIN_B2
#define I2C_PIC   PIN_B3
#define IGT_PIC   PIN_B4
#define EMOFF_PIC PIN_B5


#define puls1 input(PIN_C4)
#define puls2 input(PIN_C5)
#define puls3 input(PIN_C6)

#define ledVerde     PIN_C2
#define ledAmarillo  PIN_C1
#define ledRojo      PIN_C0

#define tamBuff 122
#define moverMotores PIN_A0
#define _timeout 60000

////////////////////////////////////////////////////////////////////////
MAIN.C
////////////////////////////////////////////////////////////////////////

#include <main.h>
#include <string.h>
#include "flex_lcd.c"
#use i2c(MULTI_MASTER ,address=0x20, sda=PIN_B0, scl=PIN_B1,SLOW, force_hw, stream=I2C)
#use rs232(baud=115200,parity=N,xmit=PIN_B7,rcv=PIN_B6,bits=8,stream = canal_debug)    

//==============================================================================
//-----------------------  DECLARACIÓN VARIABLES GLOBALES  ---------------------
//==============================================================================
   BYTE baud_rate;
   BYTE bufferRx[tamBuff], bufferTx[tamBuff];
   
   int i=0;
   int estado=0;
   BYTE incoming, state, comando;
   int1 banderaTramaGSM, banderaMano, banderaGSMOK;
   
//==============================================================================
//-----------------------  DECLARACIÓN DE FUNCIONES  ---------------------------
//==============================================================================

   void inicializaPIC(void);
   void inicializaGSM(void);
   void lecturaGSM(void);
   void estadoDeVuelta(void);
   void i2c_init(void);
   int8 i2c_mm_start(int8);
   void i2c_mm_stop(void);

//==============================================================================
//-----------------------  INTERRUPCIONES --------------------------------------
//==============================================================================

#int_SSP // interrupt on i2c activity
void  i2c_isr(void)
{

   state = i2c_isr_state();
   //Si estoy en recepcion
   if(state < 0x80){                     // Un maestro nos envia datos (algun modulo)
      //Entonces leo el bus
      incoming = i2c_read(I2C);
                 
      // Primer byte es identificador de modulo que comunica          
      if(state == 1){                    
         switch(incoming){

            case 0x51:
               banderaTramaGSM = 1;              
               break;
            case 0x52:
               banderaMano = 1;      
               break;
            default:              
               break;
         }
      }
      // Resto de los bytes son datos
      if(state == 2){                                
         comando = incoming;              
      }
      if(state > 2){
         bufferRx[state-3] = incoming;
     
      }
   }else if(state >= 0x80){                     //Master is requesting data
   
      i2c_write(bufferTx[tamBuff]);
   }
}

//==============================================================================
//-----------------------     FUNCIONES      -----------------------------------
//==============================================================================

void i2c_init() {
   baud_rate = SSPADD;
   SSPCON1 = (SSPCON1 & 0xF0) | 0x06;   // Slave mode
   SSPCON2 |= 0x01;   // Slave mode clock stretching NO MACHACA INFO
   SSPADD = 0x20;
   delay_ms(25);
   fprintf(canal_debug,"SSPADD: %u  n",SSPADD);
   enable_interrupts(INT_BUSCOL);
   enable_interrupts(INT_SSP);
}
//==============================================================================

// I2C multiMaster start
int8 i2c_mm_start(int8 address)
{
   int8 ack;
   
   disable_interrupts(INT_SSP);
   SSPCON2 &= ~0x01;
   SSPCON1 = (SSPCON1 & 0xF0) | 0x08;   // Master mode
   SSPADD = baud_rate;
   do {
      i2c_start(I2C, 1);
      ack = i2c_write(address);   // Send address with WE (returns 0 = ACK, 1 = NOACK, 2 = Collision)
   } while (ack == 2);   // Bus Collision
   return(ack);
}

//==============================================================================

// I2C multiMaster stop
void i2c_mm_stop()
{
   i2c_stop();
   while (SSPADD != baud_rate) {}
   SSPCON1 = (SSPCON1 & 0xF0) | 0x06;   // Slave mode
   SSPCON2 |= 0x01;   // Slave mode clock stretching
   SSPADD = 0x20;   // Slave mode
   clear_interrupt(INT_SSP);
   enable_interrupts(INT_SSP);
}


//==============================================================================
//==============================================================================


void inicializaPIC(void){

   //Configuracion Timer's
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);

   setup_wdt(WDT_OFF);


   //Configuracion I2C
   //enable_interrupts(INT_SSP);
   i2c_init();
   //i2c_mm_start(0x10);
  // i2c_mm_stop();
   
   //Configuracion Interrupciones
  enable_interrupts(GLOBAL);

   for(i=0;i<tamBuff;i++){
      bufferRx=0;
      bufferTx=0;
   }
   incoming=0;

   banderaTramaGSM = 0;
//   banderaMano = 0;
   banderaGSMOK = 0;
   comando = 0;


   apaga(ledVerde);
   apaga(ledAmarillo);
   apaga(ledRojo);

   estado++;
   
   return;
   
}

//==============================================================================

void inicializaGSM(void){
// Esta parte de código no interesa porque no afecta a la comunicacion
}

//==============================================================================
void lecturaGSM(void){

   int len = 0;

// Esperamos a recibir el fin de trama 0x0D 0x0A

   if (banderaTramaGSM == 1){        
     
         if(state > 3 && bufferRx[state-4]==0x0D && bufferRx[state-3]==0x0A){

            switch(comando){
               
               case 0xAA:      

                  lcd_putc("f");
                  len = strlen(bufferRx);
               
                  // Envio el mensaje recibido al PC
                  fprintf(canal_debug,"El mensaje es: %s",bufferRx);
               
                  /*
                  i2c_start(I2CM);
                  i2c_write(I2CM,0x10);      //i2c address of a slave device
                  i2c_write(I2CM,0x51);      //1st byte to slave
                  i2c_write(I2CM,0xaa);      //2nd byte to slave
                  i2c_write(I2CM,0x11);      //2nd byte to slave
                  i2c_write(I2CM,0x22);      //2nd byte to slave
                  i2c_write(I2CM,0x33);      //2nd byte to slave
                  i2c_write(I2CM,0x44);      //2nd byte to slave
                  i2c_write(I2CM,0x0D);      //2nd byte to slave
                  i2c_write(I2CM,0x0a);      //2nd byte to slave
                  i2c_stop(I2CM);
                  */
                  fprintf(canal_debug,"Mensaje enviado correctamenten");              
                  break;

      // Esto es lo que se debería mostrar si la comunicacion es exitosa
               case 0xEE:
             
                  banderaGSMOK = 1;
                  fprintf(canal_debug,"GSM conectadon");
                  lcd_putc("fSystem OK");                                  
                  enciende(ledVerde);
               
                  break;

               default:
                  fprintf(canal_debug,"Instruccion de GSM no reconocidan");
                  break;
           
            }
            //Limpio el buffer del i2c
            for(i=0;i<tamBuff;i++){
               bufferRx=0;
            }
            banderaTramaGSM = 0;
           
         }
   }else{
      estado++;
   }
}

//==============================================================================

void estadoDeVuelta(void){

   estado = 3;
   return;

}
//==============================================================================
//----------------------- PROGRAMA PRINCIPAL -----------------------------------
//==============================================================================

void main()
{
   estado = 0;

   while(TRUE){
   
      switch (estado){
   
         case 0:
            inicializaPIC();
            break;
         case 1:
            lcd_init();
            lcd_putc("fLoading System...");            
            fprintf(canal_debug,"Inicializacion LCD: OK n");
            estado++;
            break;            
         case 2:
            inicializaGSM();    
            break;
         case 3:  
            lecturaGSM();
            break;
         case 4:
            estadoDeVuelta();
            break;    
         default:
            reset_cpu();
            break;
      }
   }
}
////////////////////////////////////////////////////////////////////////

Se trata de una simple prueba para ver si dentro del modo MULTI_MASTER, cerebro puede actuar de esclavo, respondiendo a GSM.

Para este caso no se si estoy accediendo bien a los registros, si estoy haciendo bien lo que comenta Wayne_ en el foro de CCS o qué es lo que está pasando, porque no es capaz de responder.



-   Para el segundo caso se ha realizado la siguiente configuración:

CEREBRO (MULTI_MASTER) -> PIC18F2550 (identificador 0x20)
MANO (SLAVE)-> PIC16F690 (direccion esclavo 0x10)
 
Desde cerebro se disponen 2 botones uno para realizar una petición de escritura y el otro para hacer una lectura a mano. Para ello jugamos con la configuración del use i2c para cambiar el comportamiento del micro. Realizando numerosas pruebas, parece que únicamente hace caso del primer use i2c que se introduce ignorando el posterior.

/////////////////////////////////////////
CEREBRO
MAIN .C (MAIN.H ES EL MISMO QUE ANTES)
/////////////////////////////////////////

#include <main.h>
#include <string.h>
#include "flex_lcd.c"
 
//#use i2c(MASTER, sda=PIN_B0, scl=PIN_B1,SLOW, force_hw, stream=I2CM)
#use i2c(SLAVE,address=0x20, sda=PIN_B0, scl=PIN_B1,SLOW, force_hw, stream=I2CS)

#use rs232(baud=115200,parity=N,xmit=PIN_B7,rcv=PIN_B6,bits=8, stream = canal_debug)    

//==============================================================================
//-----------------------  DECLARACIÓN VARIABLES GLOBALES  ---------------------
//==============================================================================
 
   BYTE bufferRx[tamBuff], bufferTx[tamBuff];
   BYTE incoming, state, comando;
   
   int1 banderaTramaGSM, banderaMano, banderaGSMOK;
   
   int i=0;
   int estado=0;

//==============================================================================
//-----------------------  DECLARACIÓN DE FUNCIONES  ---------------------------
//==============================================================================

   void inicializaPIC(void);
   void inicializaGSM(void);
   void lecturaI2C(void);
   void estadoDeVuelta(void);
   void puls(void);


//==============================================================================
//-----------------------  INTERRUPCIONES --------------------------------------
//==============================================================================

#int_SSP // interrupt on i2c activity
void  i2c_isr(void)
{

   state = i2c_isr_state(I2CS);

   //Si estoy en recepcion
   if(state < 0x80){                     // Un maestro nos envia datos (algun modulo)
   
      //Entonces leo el bus
      incoming = i2c_read(I2CS);
                 
      // Primer byte es identificador de modulo que comunica          
      if(state == 1){                    

         switch(incoming){

            case 0x51:
               banderaTramaGSM = 1;              
               break;
            case 0x52:
               banderaMano = 1;      
               break;
            default:              
               break;
         }
      }
      // Resto de los bytes son datos
      if(state == 2){                                
         comando = incoming;              
      }
      if(state > 2){
         bufferRx[state-3] = incoming;
     
      }
   }else if(state >= 0x80){                     //Master is requesting data
   
      i2c_write(I2CS,bufferTx[tamBuff]);
   }
}


//==============================================================================
//-----------------------     FUNCIONES      -----------------------------------
//==============================================================================

void inicializaPIC(void){

   //Configuracion Timer's
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);
   setup_wdt(WDT_OFF);

   //Configuracion I2C

 
   enable_interrupts(INT_BUSCOL);
   enable_interrupts(INT_SSP);

   //Configuracion Interrupciones
   bit_clear(UCON,3);
   bit_set(UCFG,3);    
   enable_interrupts(GLOBAL);

   banderaGSMOK = 0;

   apaga(ledVerde);
   apaga(ledAmarillo);
   apaga(ledRojo);

   estado++;
   
   return;
   
}

//==============================================================================
void inicializaGSM(void){
// CÓDIGO QUE NO INTERESA YA QUE NO INTERVIENE EN LA COMUNICACION
}

//==============================================================================
//==============================================================================

void lecturaI2C(void){

   if (banderaTramaCerebro == 1){        
     
         if(state > 3 && bufferRx[state-4]==0x0D && bufferRx[state-3]==0x0A){

            switch(comando){
               
               case 0xAA:      
                  // Envio el mensaje recibido al PC
                  fprintf(canal_debug,"TIPO DATO 1 es: %s",bufferRx);
                  break;
                                         
               case 0xBB:
                  // Envio el numero recibido al PC              
                  fprintf(canal_debug,"TIPO DATO 2 es: %s",bufferRx);
                   break;

               case 0xCC:
                  // Envio el numero recibido al PC
                  fprintf(canal_debug,"TIPO DATO 3 es: %s",bufferRx);;
                  break;
               default:
                  fprintf(canal_debug,"Instruccion de GSM no reconocidan");
                  break;
            }
            //Limpio el buffer del i2c
            for(i=0;i<tamBuff;i++){
               bufferRx=0;
            }
            banderaTramaCerebro = 0;
         }
   }
 
  if (banderaTramaGSM == 1){        
         if(state > 3 && bufferRx[state-4]==0x0D && bufferRx[state-3]==0x0A){
            switch(comando){
               
               case 0xAA:      
                  // Envio el mensaje recibido al PC
                  fprintf(canal_debug,"TIPO DATO 1 es: %s",bufferRx);
                  break;
                                         
               case 0xBB:
                  // Envio el numero recibido al PC              
                  fprintf(canal_debug,"TIPO DATO 2 es: %s",bufferRx);
                   break;

               case 0xCC:
                  // Envio el numero recibido al PC
                  fprintf(canal_debug,"TIPO DATO 3 es: %s",bufferRx);
                  break;                
               default:  
                  fprintf(canal_debug,"Instruccion de GSM no reconocidan");
                  break;
            }
            //Limpio el buffer del i2c
            for(i=0;i<tamBuff;i++){
               bufferRx=0;
            }
            banderaTramaGSM = 0;
         }
   }else{
      estado++;
   }
}


//==============================================================================
void puls(void){

   int ack;
   byte datoEscribirEsclavo[4]={0x11 0x22 0x33 0x44};
   byte datoLeerEsclavo[4];
   int n=0;
   int i=0;

////////////////////////////////////////////////////////////////////////////////
//                   ESCRIBIMOS EN ESCLAVO
////////////////////////////////////////////////////////////////////////////////

   if(!puls1){
   #use i2c(MASTER, sda=PIN_B0, scl=PIN_B1,SLOW, force_hw, stream=I2CM)
      enciende(ledRojo);
      disable_interrupts(GLOBAL);
      disable_interrupts(INT_SSP);
      enable_interrupts(GLOBAL);
     do {
         i2c_start(I2CM, 1);
         ack = i2c_write(I2CM,0x10);   // Send address with WE (returns 0 = ACK, 1 = NOACK, 2 = Collision)
      } while (ack == 2);   // Bus Collision
     
      fprintf(canal_debug,"Inicio trama i2cn");
      i2c_write(I2CM,0x20);  // Indico que soy cerebro  
      i2c_write(I2CM,0xaa);  // Tipo de datos

      for(n=0;n<4;n++){
         i2c_write(I2CM,datoEscribirEsclavo[n]);   // Bucle para enviar cadena de información
      }

      i2c_write(I2CM,0x0D);  // Final de trama 1
      i2c_write(I2CM,0x0A);  // Final de trama 2    
      i2c_stop(I2CM);       // Condicion de parada
      fprintf(canal_debug,"Fin trama i2cn");
      delay_ms(500);
   }
   
////////////////////////////////////////////////////////////////////////////////
//       LEEMOS DEL ESCLAVO (NO HACE FALTA ACTIVAR INTERRUPCION I2C)
////////////////////////////////////////////////////////////////////////////////

   else if(!puls2){ // Leemos de esclavo
   #use i2c(MASTER, sda=PIN_B0, scl=PIN_B1,SLOW, force_hw, stream=I2CM)
      enciende(ledAmarillo);
      disable_interrupts(GLOBAL);
      disable_interrupts(INT_SSP);
      enable_interrupts(GLOBAL);
      do {
         i2c_start(I2CM, 1);
         ack = i2c_write(I2CM,0x10+1);   // Send address with WE (returns 0 = ACK, 1 = NOACK, 2 = Collision)
      } while (ack == 2);   // Bus Collision
     
      for(i=0;i<3;i++){
         datoLeerEsclavo=i2c_read(I2CM,1);
      }
     
      datoLeerEsclavo=i2c_read(I2CM,0);  // Ponemos el 0 indicando ultimo byte a leer
      i2c_stop(I2CM);       // Condicion de parada
      fprintf(canal_debug,"Fin trama i2cn");
      delay_ms(500);
     
      for(i=0;i<=3;i++){
         fprintf(canal_debug,"nTrama recibida %i: %x",i,datoLeerEsclavo);  //Mostramos la info
      }
     
   }else{
      apaga(ledRojo);
      apaga(ledAmarillo);
      #use i2c(SLAVE,address=0x20, sda=PIN_B0, scl=PIN_B1,SLOW, force_hw, stream=I2CS)
      disable_interrupts(GLOBAL);
      enable_interrupts(INT_SSP);
      enable_interrupts(GLOBAL);
      estado++;
   }
   return;
}

//==============================================================================
void estadoDeVuelta(void){

   estado = 3;
   return;
}

//==============================================================================
//----------------------- PROGRAMA PRINCIPAL -----------------------------------
//==============================================================================

void main()
{
   estado = 0;

   while(TRUE){
   
      switch (estado){
   
         case 0:
            inicializaPIC();
            break;
         case 1:
            lcd_init();
            lcd_putc("fSystem LOADED");            
            estado++;
            break;
         case 2:
            inicializaGSM();    
            break;
         case 3:
            lecturaI2C();    
            break;            
         case 4:
            puls();  
            break;
         case 5:
            estadoDeVuelta();
            break;    
         default:
            reset_cpu();
            break;
      }
   }
}

/////////////////////////////////////////
MANO
MAIN .H
/////////////////////////////////////////

#device adc=10

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES HS                       //Internal RC Osc, no CLKOUT
#FUSES NOPROTECT                //Code not protected from reading
#FUSES BROWNOUT                 //No brownout reset
#FUSES NOMCLR                   //Master Clear pin used for I/O
#FUSES NOCPD                    //No EE protection
#FUSES PUT                      //Power Up Timer
#FUSES IESO                     //Internal External Switch Over mode enabled
#FUSES FCMEN                    //Fail-safe clock monitor enabled

#use delay(clock=20000000)

//----------------------- DEFINICIONES -----------------------------------------

#define tamBuff 60



/////////////////////////////////////////
MANO
MAIN .C
/////////////////////////////////////////

#include <16F690.h>
#include <main.h>

#use i2c(SLAVE, sda=PIN_B4, scl=PIN_B6, address=0x10, SLOW, force_hw, stream=I2CS)
#use rs232(baud=115200,parity=N,xmit=PIN_A0,rcv=PIN_A1,bits=8,stream = canal_debug)

//==============================================================================
//-----------------------  DECLARACIÓN VARIABLES GLOBALES  ---------------------
//==============================================================================
   
   int i=0;
   int estado=0;

   BYTE state, incoming;
   BYTE bufferRx[tamBuff], bufferTx[tamBuff];

   int1 banderaTramaCerebro,banderaTramaGSM;
   BYTE comando;
   byte dato[4]={0x99 0x88 0x77 0x66};

//==============================================================================
//-----------------------  DECLARACIÓN DE FUNCIONES  ---------------------------
//==============================================================================

   void inicializaPIC(void);
   void lecturaI2C(void);

//==============================================================================
//-----------------------  INTERRUPCIONES --------------------------------------
//==============================================================================


#int_SSP // interrupt on i2c activity
void  i2c_isr(void)
{
   state = i2c_isr_state();
   
   //MODO RECEPCION
   if(state < 0x80)                     // Maestro nos envia datos
   {
      incoming = i2c_read();
      //Quien me comunica
      if(state == 1){
     
         switch(incoming){

            case 0x20:
               banderaTramaCerebro= 1;
               break;
            case 0x51:
               banderaTramaGSM = 1;    
               break;              
            default:
               fprintf(canal_debug,"No conozco quien me intenta comunicar por i2cn");            
               break;
         }
     
      //Que comando me envian
      }else if(state == 2){                      // Resto de los bytes son datos
         comando = incoming;
      }else if(state > 2){
         bufferRx[state-3] = incoming;

      }
   }
   else if(state >= 0x80)                     //Master is requesting data
   {
      i2c_write(dato[state-0x80]); // De esta forma enviamos
   }
}

//==============================================================================
//-----------------------     FUNCIONES      -----------------------------------
//==============================================================================

void inicializaPIC(void){
     
   enable_interrupts(INT_SSP);
   enable_interrupts(GLOBAL);
   
   for(i=0;i<tamBuff;i++){
      bufferRx=0;
      bufferTx=0;
   }

   banderaTramaCerebro=0;
   banderaTramaGSM=0;
   comando=0;
 
   fprintf(canal_debug,"ARRANQUE OK");
 
   estado++;

   return;
}

//==============================================================================
//==============================================================================

void lecturaI2C(void){

   if (banderaTramaCerebro == 1){        
     
         if(state > 3 && bufferRx[state-4]==0x0D && bufferRx[state-3]==0x0A){

            switch(comando){
               
               case 0xAA:      
                  // Envio el mensaje recibido al PC
                  fprintf(canal_debug,"TIPO DATO 1 es: %s",bufferRx);
                  break;
                                         
               case 0xBB:
                  // Envio el numero recibido al PC              
                  fprintf(canal_debug,"TIPO DATO 2 es: %s",bufferRx);
                   break;

               case 0xCC:
                  // Envio el numero recibido al PC
                  fprintf(canal_debug,"TIPO DATO 3 es: %s",bufferRx);;
                  break;
               default:
                  fprintf(canal_debug,"Instruccion de GSM no reconocidan");
                  break;
            }
            //Limpio el buffer del i2c
            for(i=0;i<tamBuff;i++){
               bufferRx=0;
            }
            banderaTramaCerebro = 0;
         }
   }
 
  if (banderaTramaGSM == 1){        
         if(state > 3 && bufferRx[state-4]==0x0D && bufferRx[state-3]==0x0A){
            switch(comando){
               
               case 0xAA:      
                  // Envio el mensaje recibido al PC
                  fprintf(canal_debug,"TIPO DATO 1 es: %s",bufferRx);
                  break;
                                         
               case 0xBB:
                  // Envio el numero recibido al PC              
                  fprintf(canal_debug,"TIPO DATO 2 es: %s",bufferRx);
                   break;

               case 0xCC:
                  // Envio el numero recibido al PC
                  fprintf(canal_debug,"TIPO DATO 3 es: %s",bufferRx);
                  break;                
               default:  
                  fprintf(canal_debug,"Instruccion de GSM no reconocidan");
                  break;
            }
            //Limpio el buffer del i2c
            for(i=0;i<tamBuff;i++){
               bufferRx=0;
            }
            banderaTramaGSM = 0;
         }
   }else{
      estado++;
   }
}

//==============================================================================
//==============================================================================

void estadoDeVuelta(void){

   estado = 1;
   return;
}


//==============================================================================
//----------------------- PROGRAMA PRINCIPAL -----------------------------------
//==============================================================================

void main()
{
   estado=0;
   
   while(TRUE){
     switch (estado){
         case 0:
            inicializaPIC();
            break;  
         case 1:
            lecturaI2C();
            break;
         case 2:
            estadoDeVuelta();
            break;            
         default:
            reset_cpu();
            break;
      }
   }
}


Si configuro CEREBRO como MASTER y quito en las partes del código los use i2c… funciona perfectamente (sin tocar el codigo de MANO), por lo que me da a pensar que el compilador no introduce los valores correctos en los registros cuando pongo los use i2c…

RESUMEN:
Alguno de vosotros ha trabajado con el modo MULTI_MASTER? (El objetivo es comunicar 2 PICs en modo MULTI_MASTER haciendo escrituras y peticiones de lecturas a ambos, cosa que no he llegado a hacer porque prefiero ir poco a poco y partiendo de cosas que funcionan)
Alguna idea de cómo podría manipular los registros?
#BYTE SSPADD = 0xFC8
#BYTE SSPCON1 = 0xFC6
#BYTE SSPCON2 = 0xFC5

me falta alguno más para hacerlo implementando funciones?

He intentado exponer mi problema lo más claro posible, cualquier duda estaré encantado de responderla, asi como agradecer cualquier sugerencia.

Muchisimas gracias y feliz año nuevo!

Hola, se puede hacer que una funcion devuelva varios datos??? y si es asi, como se recogen???


double miFuncion(double x, double y, double z)

{

double x, y, z;
.
.
.

return(x, y, z)
}

Hola, tengo creada una libreria con diferentes funciones  para ser utilizada desde diferentes formularios, el caso es que cuando añado una función que depende de un objeto instanciado en uno de los formularios (como un boton) la cosa no funciona.

Este es el archivo "MiLibreria.cpp" el cual incluyo en todos los formularios

Tengo 2 formularios que quieren acceder a esta funcion, el MainForm (En donde se encuentra el elemento ComboBox que quiero utilizar) y el otro es el InfoSatBox.

 void ListaSat()
{
   int sat=0;
   for(int i=0;i<MainForm->Memo->Lines->Count-1;i++)
   {
      if(sat<(MainForm->Memo->Lines->Count))
         {
         MainForm->ListarSatelites->Items->Add(MainForm->Memo->Lines->Strings[sat]);//ahi pasa por cada linea...
         MainForm->ListarSatelites->Items->Add(MainForm->Memo->Lines->Strings[sat]);//ahi pasa por cada linea...

         sat=sat+4;
         }
   MainForm->ListarSatelites->ItemIndex=0;
   }
}


que deberia hacerla, publica?, como?

un saludo y espero vuestra respuesta!