RS485, manejo de punteros

[odukec]

Hola..

No se como manejar un puntero.. la libreria para el manejo del protocolo RS485 hace uso de estos, se que un puntero "apunta" a una direccion de memoria, donde se encuentra el dato que se necesita, alguien me podria ayudar.. dandome un pequeño ejemplo..?, es que no lo logro entender muy bien..

Codigo:
//// int1 rs485_send_message(int to, int len, int* data)             ////
////     * Send a message over the RS485 bus                         ////
////     * Inputs:                                                   ////
////          to    - Destination address                            ////
////          len   - Message length                                 ////
////          *data - Pointer to message                             ////
////     * Returns TRUE if successful, FALSE if failed               ////

Digamos.. como haria en esta funcion.. que parametro le deberia enviar donde va el puntero..?

De antemano gracias.

Saludos

[oshow]

Hola Odukec, el tema de punteros siempre suele ser un poco lioso, y siempre nos da o nos ha dado problemas a todos alguna vez. Como bien dices, un puntero es una variable que "apunta" a otra
variable.

Por definicion, un puntero es una variable que contiene la ireccion en memoria de otra variable.

En el caso que planteas, vemos que en el prototipo de la funcion, se pasa como parametro int* data (entre otros), esto quiere decir que lo que se va a pasar es el puntero que apunta cierta variable, es decir, no vas a pasar la variable (llamemosla X), sino la direccion donde esta situada esa variable en la memoria (direccion de memoria de la variable X).


Para pasar u obtener la direccion de una variable, sabes que tienes que usar el operador ampersand (creo que se escribe así) , su simbolo es: &

Entonces cuando hagas la llamada a la función, sabes que como primer parámetro tienes que pasarle un entero, como segundo parametro, otro entero y como tercer parametro, el puntero o lo que es lo mismo la direccion de memoria de esa variable, por ejemplo:

Tienes tres variables:

int variable 1;
int variable 2;
int variable 3;

Pues cuando llames a la funcion, seria algo asi:

int1 rs485_send_message(variable1, variable2, &variable3) //pasamos la direccion de memoria de variable3

Con ese simbolo (&) operador direccion consigues pasar la direccion de la variable a la que apunta ese puntero. En general, ese operador sirve para hallar la direccion de memoria de cualquier variable Puedes hacer la prueba con cualquier variable y un lcd.

El porque de pasar la direccion de memoria a la funcion en lugar de la propia variable como en los dos primero parametros, es debido a que las funciones pasan "copias" de las variables, es
decir, si en tu variable3 tienes almacenado el valor 27 y dentro de la funcion quieres cambiar el valor de variable3 a 30 (por ejemplo) no puedes hacerlo, porque has pasado a la funcion una copia del numero 27 y la variable no se modifica, sin embargo, si pasas la direccion de la memoria de la variable, si puedes acceder directamente a esa variable y modificarla dentro de la función.

Espero haberte sido de ayuda, aunque sé, que lo mio no es explicarme.

Esto ya es de por sí un tema lioso y encima contandotelo yo, lo puede ser aún más jejej.

Te recomiendo que si puedes, visites estos enlaces, seguramente esté mejor explicado de lo que lo yo he escrito:

Como teoria el Tema 7 del siguiente enlace, está bastante bien explicado y concretamente el

epígrafe 7.4 te puede interesar mucho:

http://labsopa.dis.ulpgc.es/cpp/intro_c/introcfc.htm

Para saber el porqué de pasar la direccion de una variable a una funcion, leete este página y los post de Modulay, pienso que lo deja bastante claro y encima con un ejemplo que puede resultar
clarificador:

http://miarroba.com/foros/ver.php?foroid=46840&temaid=2307248&pag=3


Un saludo.

[odukec]

Hola. oshow..

Me parece excelente tu explicacion.. yo se lo de paremetros por referencia y eso.. solo que como dices tu es algo lioso, pero tu post me aclaro dudas..

Bueno.. sera hacer el programa y probar.. no.?

Muchas gracias de nuevo

Saludos

[Nocturno]

Oshow, creo que te has explicado como un libro abierto.

Por cierto, ese link está muy guay

[CARLOSXR7]

Escrito originalmente por odukec

...No se como manejar un puntero.. la libreria para el manejo del protocolo RS485 hace uso de ...

Codigo:
//// int1 rs485_send_message(int to, int len, int* data)             ////
////     * Send a message over the RS485 bus                         ////
////     * Inputs:                                                   ////
////          to    - Destination address                            ////
////          len   - Message length                                 ////
////          *data - Pointer to message                             ////
////     * Returns TRUE if successful, FALSE if failed               ////

Saludos Amigo Odukec, disculpa, una pregunta, donde se encuentra dicha libreria, que puede manejar RS485, lo que sucede es que debo hacer una red con micros, y los quiero programar en CCS, pero quiero hacer mi codigo entendible, porque necesito hacer muchas funciones, asi que esas funciones para manejar RS485 serian fabulosas para mi, ¿donde puedo conseguirlas?, te agradezco tu ayuda de antemano, hasta luego

[kruskal]

Revisen este link para un curso de C mucho mas completo, sirve tanto para principiantes como avanzados

http://c.conclase.net/curso/index.php

Salud2

[odukec]

Hola..

La verdad esa libreria no funciona muy bien.. habian muchos errores en la comunicación, en la pagina de PACALACONCURSO hay una rutina para recibir paquetes.. y la verdad funciona muy bien, la complemente con unas rutinas para tratar los paquetes recibidos, y enviar paquetes, bueno.. no la tengo ahora.. pero mas tarde la posteo.

Saludos

[YF-21]

Cual es la diferencia entre el rs232 y rs485?. El rs232 se maneja para comunicaciones entre modem (puede salir de las computadoras) pero como se maneja el rs485, tambien puede salir de las computadoras?.

Tambien vi que existen convertidores de rs232 a rs485, que sucede con esos?

[odukec]

Hola

Bueno.. la ventaja del RS485 es que es una comunicación multipunto, osea para redes, se pueden alcanzar grandes distancias alcanzando velocidades de transmision de datos de hasta 10 Mbps por medio de dos "twisted pair" o dos cables trenzados,  claro hay que crear un protocolo, pero en realidad tiene muchas ventajas.. porque una red RS485 puede soportar muchos dispositivos, y la comunicación es muy fiel. Bueno, mas bien dejo este link en el que explican todo mucho mejor --> http://www.embedded.com.ar/ en el link interfaces y buses TIA/EIA 485

Esa página es excelente.

Saludos.

[YF-21]

Gracias odukec por el link, ahora me estoy empapando de informacion (a ver que aprendo) y tambien le estoy echando un ojo a la pagina de pacalaconcurso ...

[gfp]

Escrito originalmente por odukecHola..

La verdad esa libreria no funciona muy bien.. habian muchos errores en la comunicación, en la pagina de PACALACONCURSO hay una rutina para recibir paquetes.. y la verdad funciona muy bien, la complemente con unas rutinas para tratar los paquetes recibidos, y enviar paquetes, bueno.. no la tengo ahora.. pero mas tarde la posteo.

Saludos

Actualmente desarrollo un proyecto que consiste en medir varios voltajes DC de unos equipos de comunicaciones ubicados en la cima de una torre de comunicaciones. Es decir que estos equipos estan arriba al lado de la antena.
La idea numero uno es utilizar el protocolo RS485 como medio de transporte de los datos y para ello implementé el driver "RS485.C" incluido en el CCS y la verdad no encuentro problema alguno tal y como lo menciona mi compatriota "odukec".
Hasta el momento tengo un maestro que interroga a  8 esclavos y el proyecto trabaja a la perfección.

gfp

[odukec]

Bueno..
no se que decir, yo la implemente y no me funciono, tal vez hice algo mal, el caso es que con estas si me funciona a la perfección, y la comunicacion casi nunca tiene errores, estoy depurandolas, son modificaciones de algunos ejemplos del CCS y tambien esta basado en la recepción serie que tiene en su página PACALACONCURSO, si alguien quiere mejorarla o hacerle una corrección serán bien recibidas.

Codigo:
#use rs232(baud=9600,bits=8,parity=N,xmit=PIN_C6,rcv=PIN_C7,stream=COM1)
#use rs232(baud=9600,bits=8,parity=N,xmit=PIN_C6,rcv=PIN_C7,force_sw,stream=COM2)

#define BUFFER_SIZE 20

int packet_buffer[BUFFER_SIZE];

////////////////////////////////////////////////////////////////////////////////
/// Estructura variables comunicacion serial ///////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

struct _comm{
   int1 nuevo_paquete;     //hay un nuevo paquete a analizar
   int8 cuenta_rx;         //caracteres recibidos en el ultimo paquete
   BYTE trama[BUFFER_SIZE];
   int1 ocupado;           //flag que indica si estamos procesando un paquete
   BYTE byt;               //caracter dummy, para sacar del puerto serie
} comm;


////////////////////////////////////////////////////////////////////////////////
/// Interrupción timer1 para timeout tiempo para saber si hay datos nuevos /////
////////////////////////////////////////////////////////////////////////////////

#int_TIMER1
void TIMER1_isr(){
   disable_interrupts(int_TIMER1);
   comm.ocupado=1;               // No mas recepción de mensajes..
   comm.nuevo_paquete=1;         // Paquete a la espera de ser analizado
}

////////////////////////////////////////////////////////////////////////////////
/// Interrupción serial para entrada de datos //////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

#int_rda
void serial_isr(){
   comm.byt=fgetc(COM1);         // recoge dato byte entrante
   if (!comm.ocupado){           // si estamos procesando un envió no se hace caso..
      comm.trama[comm.cuenta_rx++]=comm.byt;
      set_timer1(30000);         // esperar el tiempo que deseemos como timeout
      clear_interrupt(int_TIMER1);  // limpiar el flag de overflow del timer1
      enable_interrupts(int_TIMER1);
   }
}

#define CRC_CCITT 0x1021      //bit pattern (1)0001 0000 0010 0001
#include <CRC.C>

////////////////////////////////////////////////////////////////////////////////
/// Funcion que espera el bus para evitar colisiones ///////////////////////////
////////////////////////////////////////////////////////////////////////////////

void espera_bus(void){
   int16 i;

   setup_uart(FALSE);               // Deshabilita UART para falsas recepciones
   for(i=0; i <= 400; ++i){         // Espera aproximadamente 20 ms si el bus esta libre
      if(!input(PIN_C7))            // sino se queda a la espera
         i = 0;
      else
         delay_us(50);
   }
}


// SEND_PACKET
// Función que envia paquete a otro dispositivo
void send_packet(int* packet_ptr, int16 packet_length)
{
   int *ptr;
   int16 CRC,i;

   espera_bus();                       // Espera el bus para evitar colisiones

   output_high(enable_rcv_max);        // Habilita salida datos max485

   ptr = packet_ptr;                            // puntero a paquete

   CRC = generate_16bit_crc(ptr, packet_length, CRC_CCITT);
                                                // crea CRC
   for(i=0; i<packet_length; i++)               // envia paquete
      fputc(packet_ptr,COM2);

   fputc((int)(CRC>>,COM2);                         // envia CRC
   fputc((int)(CRC),COM2);

   delay_ms(10);

   output_low(enable_rcv_max);
   setup_uart(TRUE);

}

// GET_PACKET
// Función que procesa el paquete y analiza si es valido o no
// espera TRUE  -> Espera paquete
//        FALSE -> No espera paquete
short get_packet(int* packet_ptr, int1 espera)
{
   short retval;
   int16 length;
   int16 CRC;
   int16 i;

   retval = TRUE;

   if(espera){
      while(!comm.nuevo_paquete);            // Espera que halla nuevo paquete
   }else{
      if(!comm.nuevo_paquete){               // si no lo hay retorna cero
         return(FALSE);
      }
   }

   packet_ptr[0] = comm.trama[0];              // Direccion destino paquete
   packet_ptr[1] = comm.trama[1];              // direccion de donde viene paquete

   if(packet_ptr[0] != MACHINE_ADDRESS){
      comm.ocupado=0;               // Habilita recepción de nuevos datos
      comm.nuevo_paquete=0;         // ya no hay mas datos
      comm.cuenta_rx=0;             // Contador de index de datos a cero
      return(FALSE);
   }

   packet_ptr[2] = comm.trama[2];              // Byte ACK o NACK
   if(packet_ptr[2] == NACK){
      comm.ocupado=0;               // Habilita recepción de nuevos datos
      comm.nuevo_paquete=0;         // ya no hay mas datos
      comm.cuenta_rx=0;             // Contador de index de datos a cero
      return(FALSE);
   }

   packet_ptr[3] = comm.trama[3];              // Tamaño de datos en el paquete
   packet_ptr[4] = comm.trama[4];

   length = make16(packet_ptr[3],packet_ptr[4]);

   for(i=5; i<(length+5); i++)                  // recoje los datos
      packet_ptr = comm.trama;

   packet_ptr[length+5] = comm.trama[length+5];       // recoje CRC
   packet_ptr[length+6] = comm.trama[length+6];

   CRC = make16(packet_ptr[length+5],packet_ptr[length+6]);

   if(CRC != generate_16bit_crc(packet_ptr, length+5, CRC_CCITT)){   // Analisis CRC
      ext_buffer[0]=packet_buffer[1];  //En caso de CRC malo envia NACK
      ext_buffer[1]=MACHINE_ADDRESS;
      ext_buffer[2]=NACK;
      ext_buffer[3]=0;
      ext_buffer[4]=1;
      ext_buffer[5]=NACK;
      send_packet(ext_buffer,6);
      retval = FALSE;
   }

   comm.ocupado=0;               // Habilita recepción de nuevos datos
   comm.nuevo_paquete=0;         // ya no hay mas datos
   comm.cuenta_rx=0;             // Contador de index de datos a cero

   return retval;
}

Saludos

[eca251]

Escrito originalmente por gfp

Escrito originalmente por odukecHola..

La verdad esa libreria no funciona muy bien.. habian muchos errores en la comunicación, en la pagina de PACALACONCURSO hay una rutina para recibir paquetes.. y la verdad funciona muy bien, la complemente con unas rutinas para tratar los paquetes recibidos, y enviar paquetes, bueno.. no la tengo ahora.. pero mas tarde la posteo.

Saludos

Actualmente desarrollo un proyecto que consiste en medir varios voltajes DC de unos equipos de comunicaciones ubicados en la cima de una torre de comunicaciones. Es decir que estos equipos estan arriba al lado de la antena.
La idea numero uno es utilizar el protocolo RS485 como medio de transporte de los datos y para ello implementé el driver "RS485.C" incluido en el CCS y la verdad no encuentro problema alguno tal y como lo menciona mi compatriota "odukec".
Hasta el momento tengo un maestro que interroga a  8 esclavos y el proyecto trabaja a la perfección.

gfp

hola disculpa mi ignorancia ,veras yo estoy haciendo u proyecto algo parecido ,lo mio es solo controlar dos esclavos desde mi master q seria mi pc y bueno estos reciben y entregan datos (son dos microcontrolaodres, q ya los tengo echos )los micros q tengo tiene un puerto de comunicacion 232 al igual q mi pc ,entonces veo q necesito un interface de 232 a 485 y luego como hago para conectarme alos micros si tienen puerto 232 y soportan voltaje TTl q no lo tiene la red 485,haber sime ayudas con el driver y el programa por favor he encontardo un  interface de 232 a 485  pero no se si funcione seria cuestion d eprobar y bueno e leido delmax 485 q convierte a voltajesde TTL ,la preg es ¿ cómo lo conecto ?y coom le digo a mi prog hacia a donde van los datos bueno el lenguaje de prog q debo de usar es C el mod de transmicion y recepcion es Half-duplex gracias ojal me puedas ayudar espeor me entiendas  

[eca251]

Escrito originalmente por odukecBueno..
no se que decir, yo la implemente y no me funciono, tal vez hice algo mal, el caso es que con estas si me funciona a la perfección, y la comunicacion casi nunca tiene errores, estoy depurandolas, son modificaciones de algunos ejemplos del CCS y tambien esta basado en la recepción serie que tiene en su página PACALACONCURSO, si alguien quiere mejorarla o hacerle una corrección serán bien recibidas.

Codigo:
#use rs232(baud=9600,bits=8,parity=N,xmit=PIN_C6,rcv=PIN_C7,stream=COM1)
#use rs232(baud=9600,bits=8,parity=N,xmit=PIN_C6,rcv=PIN_C7,force_sw,stream=COM2)

#define BUFFER_SIZE 20

int packet_buffer[BUFFER_SIZE];
hola disculpa mi ignorancia ,veras yo estoy haciendo u proyecto algo parecido ,lo mio es solo controlar dos esclavos desde mi master q seria mi pc y bueno estos reciben y entregan datos (son dos microcontrolaodres, q ya los tengo echos )los micros q tengo tiene un puerto de comunicacion 232 al igual q mi pc ,entonces veo q necesito un interface de 232 a 485 y luego como hago para conectarme alos micros si tienen puerto 232 y soportan voltaje TTl q no lo tiene la red 485,haber sime ayudas con el driver y el programa por favor he encontardo un interface de 232 a 485 pero no se si funcione seria cuestion d eprobar y bueno e leido delmax 485 q convierte a voltajesde TTL ,la preg es ¿ cómo lo conecto ?y coom le digo a mi prog hacia a donde van los datos bueno el lenguaje de prog q debo de usar es C el mod de transmicion y recepcion es Half-duplex gracias ojal me puedas ayudar espeor me entiendas ha una duda mas hablan de ccs a q se refieren otra ves gracias 

////////////////////////////////////////////////////////////////////////////////
/// Estructura variables comunicacion serial ///////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

struct _comm{
   int1 nuevo_paquete;     //hay un nuevo paquete a analizar
   int8 cuenta_rx;         //caracteres recibidos en el ultimo paquete
   BYTE trama[BUFFER_SIZE];
   int1 ocupado;           //flag que indica si estamos procesando un paquete
   BYTE byt;               //caracter dummy, para sacar del puerto serie
} comm;


////////////////////////////////////////////////////////////////////////////////
/// Interrupción timer1 para timeout tiempo para saber si hay datos nuevos /////
////////////////////////////////////////////////////////////////////////////////

#int_TIMER1
void TIMER1_isr(){
   disable_interrupts(int_TIMER1);
   comm.ocupado=1;               // No mas recepción de mensajes..
   comm.nuevo_paquete=1;         // Paquete a la espera de ser analizado
}

////////////////////////////////////////////////////////////////////////////////
/// Interrupción serial para entrada de datos //////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

#int_rda
void serial_isr(){
   comm.byt=fgetc(COM1);         // recoge dato byte entrante
   if (!comm.ocupado){           // si estamos procesando un envió no se hace caso..
      comm.trama[comm.cuenta_rx++]=comm.byt;
      set_timer1(30000);         // esperar el tiempo que deseemos como timeout
      clear_interrupt(int_TIMER1);  // limpiar el flag de overflow del timer1
      enable_interrupts(int_TIMER1);
   }
}

#define CRC_CCITT 0x1021      //bit pattern (1)0001 0000 0010 0001
#include <CRC.C>

////////////////////////////////////////////////////////////////////////////////
/// Funcion que espera el bus para evitar colisiones ///////////////////////////
////////////////////////////////////////////////////////////////////////////////

void espera_bus(void){
   int16 i;

   setup_uart(FALSE);               // Deshabilita UART para falsas recepciones
   for(i=0; i <= 400; ++i){         // Espera aproximadamente 20 ms si el bus esta libre
      if(!input(PIN_C7))            // sino se queda a la espera
         i = 0;
      else
         delay_us(50);
   }
}


// SEND_PACKET
// Función que envia paquete a otro dispositivo
void send_packet(int* packet_ptr, int16 packet_length)
{
   int *ptr;
   int16 CRC,i;

   espera_bus();                       // Espera el bus para evitar colisiones

   output_high(enable_rcv_max);        // Habilita salida datos max485

   ptr = packet_ptr;                            // puntero a paquete

   CRC = generate_16bit_crc(ptr, packet_length, CRC_CCITT);
                                                // crea CRC
   for(i=0; i<packet_length; i++)               // envia paquete
      fputc(packet_ptr,COM2);

   fputc((int)(CRC>>,COM2);                         // envia CRC
   fputc((int)(CRC),COM2);

   delay_ms(10);

   output_low(enable_rcv_max);
   setup_uart(TRUE);

}

// GET_PACKET
// Función que procesa el paquete y analiza si es valido o no
// espera TRUE  -> Espera paquete
//        FALSE -> No espera paquete
short get_packet(int* packet_ptr, int1 espera)
{
   short retval;
   int16 length;
   int16 CRC;
   int16 i;

   retval = TRUE;

   if(espera){
      while(!comm.nuevo_paquete);            // Espera que halla nuevo paquete
   }else{
      if(!comm.nuevo_paquete){               // si no lo hay retorna cero
         return(FALSE);
      }
   }

   packet_ptr[0] = comm.trama[0];              // Direccion destino paquete
   packet_ptr[1] = comm.trama[1];              // direccion de donde viene paquete

   if(packet_ptr[0] != MACHINE_ADDRESS){
      comm.ocupado=0;               // Habilita recepción de nuevos datos
      comm.nuevo_paquete=0;         // ya no hay mas datos
      comm.cuenta_rx=0;             // Contador de index de datos a cero
      return(FALSE);
   }

   packet_ptr[2] = comm.trama[2];              // Byte ACK o NACK
   if(packet_ptr[2] == NACK){
      comm.ocupado=0;               // Habilita recepción de nuevos datos
      comm.nuevo_paquete=0;         // ya no hay mas datos
      comm.cuenta_rx=0;             // Contador de index de datos a cero
      return(FALSE);
   }

   packet_ptr[3] = comm.trama[3];              // Tamaño de datos en el paquete
   packet_ptr[4] = comm.trama[4];

   length = make16(packet_ptr[3],packet_ptr[4]);

   for(i=5; i<(length+5); i++)                  // recoje los datos
      packet_ptr = comm.trama;

   packet_ptr[length+5] = comm.trama[length+5];       // recoje CRC
   packet_ptr[length+6] = comm.trama[length+6];

   CRC = make16(packet_ptr[length+5],packet_ptr[length+6]);

   if(CRC != generate_16bit_crc(packet_ptr, length+5, CRC_CCITT)){   // Analisis CRC
      ext_buffer[0]=packet_buffer[1];  //En caso de CRC malo envia NACK
      ext_buffer[1]=MACHINE_ADDRESS;
      ext_buffer[2]=NACK;
      ext_buffer[3]=0;
      ext_buffer[4]=1;
      ext_buffer[5]=NACK;
      send_packet(ext_buffer,6);
      retval = FALSE;
   }

   comm.ocupado=0;               // Habilita recepción de nuevos datos
   comm.nuevo_paquete=0;         // ya no hay mas datos
   comm.cuenta_rx=0;             // Contador de index de datos a cero

   return retval;
}

Saludos

[zagoaristides]

Hola..

La verdad esa libreria no funciona muy bien.. habian muchos errores en la comunicación, en la pagina de PACALACONCURSO hay una rutina para recibir paquetes.. y la verdad funciona muy bien, la complemente con unas rutinas para tratar los paquetes recibidos, y enviar paquetes, bueno.. no la tengo ahora.. pero mas tarde la posteo. <img   src="http://pics.miarroba.com/caretos/wink.gif" alt="Giño" title="Giño" />

Saludos

Me la pasarías por favor que estoy renegando muchísimo con esto del RS485, hace 1 semana y nada. mi hotmail es zagoaristides

 Muchas gracias