INCLUIR NULL EN ARREGLO Y ENVIAR VIA UART

[ALFREDOSKY]

Hola a todos, me he encontrado con un problemilla al programar el envío serial con PIC's, sucede que deseo incluir dentro de un arreglo un byte null (0x00), o sea interpretarse como dato y NO como indicador de fin de string usando el modulo UART de un pic, creo que esto se adapta a todos los casos sin importar si es un pic de 8, 16 o 8 bits. Cuando agrego a un campo del arreglo este byte, los datos enviados son incorrectos. Para ser mas claro, tengo un arreglo llamado envio[20] de tipo BYTE, digamos que cada campo lo lleno de esta manera:(se que así no es posible llenarlo pero es una manera gráfica de explicar mi problema)

envio[0] = 0x41; (ascii de letra A)
envio[1] = 0x42;
.
.
.
envio[8] = 0x00; ( NULL) no es fin de trama, es un dato
envio[9] = 0x2F;
.
.
.
envia[19] = 0x4D;

uso una función que envía el puntero a este arreglo y su longitud, algo así:

void enviar_cadena(void*ptr_array, int longitud_array);

pero como digo, los datos enviados son incorrectos, al cambiar

envio[8] = 0x00      a      envio[8] = 0x3E;

y vuelvo a enviar, ahora si envía correctamente los datos; Como verán lo que deseo es enviar un NULL, pero no se como, a pesar que le doy la longitud del arreglo en la funcion(es decir pongo 20), la trama se corta en ese NULL

Porfavor si alguien tiene una sugerencia o idea de como proceder, se lo agradecería muchisimo 

[KALLITOS]

lo que pasa es que el caracter "\0" es usado por el compilador para indicar que ya no hay caracteres en la cola, lo que debes hacer es enviarlos manualmente, seria bueno que muestres tu codigo.

Lo que yo haría es:

for(cont = 0;cont<longitud_array;cont++)
{
U1TXREG = envio[cont];
//para continuar puedes habilitar la interrupcion de TX uart o esperar a que el hard te ponga el flag de fin de envío de uart.
}

puede que tu codigo de envío este correcto, pero pasar una cadena a una funcion el compilador toma el "\0" como fin de cadena y ya no pasa nada mas.

Para evitar eso, declara tu cadena envio como gloal y llámala desde la función; a esta función sólo le pasas el valor de la variable que lleva la cantidad de caracteres a enviar.

saludos.

[donvalles]

hola, me parece pero no estoy 100% seguro, pero el caracter null del compilador es 0x00 por eso finaliza el envio en ese punto. fijate en el codigo ascii 0x00 es el caracter NULL. Saludos.

[ALFREDOSKY]

Gracias por sus respuestas KALLITOS y donvalles, KALLITOS he intentado el método manual, pero igual se corta al encontrar el null, también he declarado global el arreglo y a la función que realiza el envío solo le paso como argumento el tamaño pero con los mismos resultados, se corta al encontrar el null; donvalles así es, el byte NULL es 0x00, pero sucede que yo quiero enviar esta valor como dato, o sea, digamos que 2bytes indican una función a realizar en el lado del receptor, si envío 0x003A, el primer byte(0x00) indica, por ejemplo, elegir un motor por default, si el mismo primer byte lo cambio por 0x01 indica, también como ejemplo, elegir el motor 1 y asi con otros valores, es ahí donde radica la importancia de enviar ese byte con 0x00, pero como veras, el modulo uart interpreta ese byte como fin de trama cosa que no quiero que haga, quiero corregir eso, seguire intentando algunas cosas mas, si resulta lo comento, mientras tanto espero alguien se apiade de mi sufrimiento y me de una mano 

[KALLITOS]

Coloca tu codigo para observar donde esta el problema.

[ALFREDOSKY]

KALLITOS el codigo es grande, pero basicamente y resumiendo, tengo esto:


BYTE  arreglo_trama[10];


void enviar_trama(int longitud);
void pasar_estructura_a_arreglo(void* p_PEAA);


typedef struct trama{
  WORD elegir_motor;
  WORD id_comando;
  WORD estado_motor;
}TRAMA;

TRAMA *p;


void main()
{
   p->elegir_motor = 0x0001;  ---> AQUI EL PRIMER BYTE ES 0x00
   p->id_comando = 0x0203;
   p->estado_motor = 0x0504;

   pasar_estructura_a_arreglo(p);
  
   while(PORTBbits.RB0 == 1){   //cada vez que se presiona un boton asociado a este pin del puerto B, se envia trama
   enviar_trama(10);
   }
}


void pasar_estructura_a_arreglo(void *p_PEAA)
{
  int r;  

  for(r = 0; r<sizeof(TRAMA); r++)
   arreglo_trama[r] = *p_PEAA++;
}

void enviar_trama(int longitud)
{
  int k;
  for(k = 0; k < longitud; k++)
      U1TXREG = arreglo_trama[k];
}

pero siempre se corta el string  

[KALLITOS]

La funcion pasar estructura es la que corta  la data, ejecuta esa parte de codigo dentro del main para que pruebes.
saludos

[BrunoF]

Que micro estas usando? Porque si es uno de gama baja o media me sorprende que no estés overflodeando el buffer de salida de la uart.

Los 10 bytes se deberían estar enviando aunque sean todos sus bytes 0x00. Todo me indica que tenes un problema en el código que recibe la trama, que esta leyendo un string en lugar de información RAW. Por eso ves que se corta.

Saludos

[ALFREDOSKY]

KALLITOS, voy a probar lo que me dices, pero si es asi, no se porque la funcion pasar_estructura_a_arreglo cortaria los datos; seria malo, ya que se supone que debo usar esa funcion fuera del main ya que la aplicacion que estoy haciendo es para llenar los campos de la estructura llamando a funciones especificas, una vez llamadas estas funciones, llamo a pasar_estructura_a_arreglo para luego enviar la data presionando el boton, el codigo que muestro es un prototipo de lo que sera realmente en el futuro, pero si no funciona asi como esta, no serviria.

BrunoF, estoy usando un PIC32MX795F512L, el registro UxTXREG es de 32 bits, creo que tenia claro que no habria desborde tal y como esta escrito el codigo, ya que le estoy pasando 1byte a la vez y se esta tx en ese momento por asi decirlo, si fuera un pic de 8 bits, seria igual, no habria desborde salvo que le pase un dato de tipo WORD o DWORD o sea de 16 o 32 bits, porfavor si me puedes aclarar eso te lo agradeceria, probablemente estoy equivocado.

Cuando dices:

Todo me indica que tenes un problema en el código que recibe la trama, que esta leyendo un string en lugar de información RAW

te refieres a la parte del receptor no es asi?, bueno en realidad, yo estoy debuggeando el codigo, pongo breakpoints y veo si el arreglo se llena correctamente andes de enviarlo, es ahi donde veo que esta incompleto, es decir, no tengo un codigo desarrollado en el lado del receptor (pienso usar un dspic30f2010), saludos

[BrunoF]

Me he expresado mal. Lo que quise decir ha sido FIFO. Ahora que se que modelo de pic usas, veo en su datasheet que el tamaño de cada FIFO de cada USART es de 8 elementos, sin embargo tu le cargas los 10 elementos uno detrás del otro sin demora suficiente o mejor aun recurriendo a los flags correspondientes del módulo para saber si hay lugar en el FIFO de envío para que puedan ser cargados. Enviar eso así como lo haces, mínimamente y seguro produce que los primeros elementos a enviar sean sobre escritos en el FIFO por los últimos (que son siempre 0x00 siendo que estas enviando un array de 10 elementos de los cuales la estructura solo escribe los primeros 6).

[ALFREDOSKY]

BrunoF tienes razon, creo que una manera de controlar eso es consultar sobre si se transmitio efectivamente el ultimo elemento, lo corrijo:

void enviar_trama(int longitud)
{
  int k;
  for(k = 0; k < longitud; k++){
     while(U1STABits.UTXBF);
      U1TXREG = arreglo_trama[k];
  }
}

pero sigo con el problema inicial, el string se sigue cortando

[KALLITOS]

Hola, alfredo probaste poniendo el codigo de pasar_estructura_a_arreglo dentro del main?
Primero haz eso, confirma que el codigo hace lo que quieres y luego ya pasalo a una función.

saludos

[ALFREDOSKY]

Ohhhh KALLITOS eres un maestro!!    eso era, y la verdad no se porque si funciona en el main y no fuera de el,  pero ahora estoy metido en otro problema, se supone que esa funcion de pasar los datos de la estructura al arreglo para luego enviarlo de manera serial debo llamarla pasando el parametro de alguna estructura en particular, por eso la hice funcion, para pasarle el puntero a esa estructura, en el ejemplo muestro una estructura pero en realidad son varias...pero bueno, otro dolor de cabeza que tratare de resolver; me has sacado de un atasco, te agradezco infinitamente tu colaboracion