Autor Tema: como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?  (Leído 2292 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado johenrod

  • PIC16
  • ***
  • Mensajes: 247
Cordial saludo, requiero almacenar datos de tags de tarjetas RFID las  cuales tiene un ancho de 32 bits, se que hay una función que aun no utilizo make8(), make16() y make32() para este fin,
al parecer puedo segmentar los 4 bytes  y guardarlos en la posiciones EEPROM 0,1,2 y 3 hasta aquí todo parece ir bien pero eso es para 1 sola tarjeta, cuando quiera almacenar otras tarjetas, como se donde debo escribir para no sobrescribir en posiciones ya utilizadas y de igual forma cuando vaya a realizar la lectura de una tarjeta ya almacenada (comparar) como se efectuaría la comparación.
Gracias de antemano.
Si algo parece complicado... es por que esta mal explicado.

Desconectado remi04

  • PIC24F
  • *****
  • Mensajes: 657
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #1 en: 28 de Febrero de 2021, 18:40:59 »
Ahí yo haría dos cosas.

  1-  dos funciónes específicas que sean las únicas en todo el programa que tengan acceso a la memoria eeprom.  Una seria de lectura, a la cual le envías el índice de tarjeta que quieres leer y ella te devuelve el rfid de ese índice. 


Código: C
  1. int32 read_rfid_card(int index) {
  2.   return make32(read_eeprom(index*4),read_eeprom((index*4)+1),read_eeprom((index*4)+2),read_eeprom((index*4)+3));
  3. }

Para llamar a esta función:

Código: C
  1. int32 rfid = read_rfid_card(4);   // dame el rfid de la tarjeta número 4





de esa forma tú le mandas el índice de tarjeta, por ejemplo, la tarjeta número 4, y el va a buscarla en las direcciones 4*4,  4*4+1, 4*4+2,  4*4+3, es decir, posiciones: 16,17,18 y 19 respectivas. 

  Nunca hay posibilidad de cruzar ni solapar nada.

  Para grabar una tarjeta le mandas a esta función el código rfid de la misma y el índice de número de tarjeta donde se grabará ese rfid:

Código: C
  1. void write_rfid_card(int32 rfid,int index) {
  2.   write_eeprom(index * 4, make8(rfid,3));
  3.   write_eeprom((index * 4) + 1, make8(rfid,2));
  4.   write_eeprom((index * 4) + 2, make8(rfid,1));
  5.   write_eeprom((index * 4) + 3, make8(rfid,0));
  6. }


La forma de usar la función sería:

Código: C
  1. // int32 rfid = 1234567890;     // rfid que has leído de una tarjeta física.
  2. wtite_rfid_card(rfid,4);     // graba  el código rfid en el índice 4.

Y ya para tener un plus de seguridad extra, implementaría un CRC8.  Reservaria un quinto byte a cada tarjeta.  Cuando vayas a grabar un rfid, le calculas el CRC8 a ese rfid con los 4 bytes que lo componen, y ese CRC8 lo grabas en una quinta posición.

   Entonces en las funciones anteriores tendrías que agregar un quinto byte a cada rfid para calcular y grabar el CRC8 en la que graba y luego leer el CRC8 en la que lee y comprobarlo para validarlo.

  Eso ya te aseguraría que lo que estás leyendo corresponde a un rfid real y no a algo de 4 bytes que se te hayan cruzado.   

  Pero vamos, que sería difícil que con las funciones anteriores se te cruce nada salvo que tengas desbordamiento de dirección por llegar a ocupar toda la eeprom entera. Tienes que agregar control para limitar el índice al número maximo de tarjetas que te caben en la eeprom.

 Saludos.
« Última modificación: 28 de Febrero de 2021, 18:54:33 por remi04 »

Desconectado johenrod

  • PIC16
  • ***
  • Mensajes: 247
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #2 en: 28 de Febrero de 2021, 19:06:42 »
Citar
Ahí yo haría dos cosas.

  1-  dos funciónes específicas que sean las únicas en todo el programa que tengan acceso a la memoria eeprom.  Una seria de lectura, a la cual le envías el índice de tarjeta que quieres leer y ella te devuelve el rfid de ese índice.


Código: C
int32 read_rfid_card(int index) {
  return make32(read_eeprom(index*4),read_eeprom((index*4)+1),read_eeprom((index*4)+2),read_eeprom((index*4)+3));
}
 
remi04
Gracias por tu respuesta..

cuando coloque una tarjeta cualquiera, tendría que explorar toda la eeprom para ir comparando si esta existe?
Eso seria algo demorado o no?
« Última modificación: 28 de Febrero de 2021, 19:10:12 por johenrod »
Si algo parece complicado... es por que esta mal explicado.

Desconectado remi04

  • PIC24F
  • *****
  • Mensajes: 657
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #3 en: 28 de Febrero de 2021, 19:20:53 »
Con el CRC8 sería la forma más rápida.

  Si tienes 4 bytes de un rfid seguido de un byte con un CRC8 calculado sobre esos 4 bytes entonces la búsqueda solo la haces en los crc8’s y no en toda la eeprom.

  Por ejemplo:

  Meten una tarjeta. Su rfid es 1234567890.

 Lo que haces es calcular su CRC8, y ahora lanzas la búsqueda en la eeprom de un CRC8 que tenga un valor idéntico.  Así solo tienes que buscar en los bytes 4,9,14,19, sucesivamente que son los que tienen el crc de los 4 bytes que lo preceden y no en toda la eeprom.

 Una vez localizado pues lees el rfid (los 4 bytes anteriores a ese CRC),  y lo comparas con el rfid leído.  Si coincide ya lo tienes.

  Es mucho más rápido.

  Y si quieres que sea aún más rápido, al arranque del programa lees toda la eeprom (solo los crc) y te haces un array donde almacenas los CRC8 por orden que hay en la eeprom. Es un index en ram de todos los rfid que hay en la eeprom.   Así aceleras muchísimo la búsqueda a la hora que metan una tarjeta en el sistema a ver si está o no está puesto que si encuentras su crc por ejemplo en el índice 9, pues usas las funciones anteriores para leer a tiro directo ese rfid en la eeprom y luego lo comparas.   Es muy difícil que te salga un crc duplicado pero puede pasar, por eso siempre que localices, lees el rfid y lo comparas. Si no es, sigues buscando el siguiente crc que coincida ...  es como buscar en un listín.

 
« Última modificación: 28 de Febrero de 2021, 19:39:28 por remi04 »

Desconectado johenrod

  • PIC16
  • ***
  • Mensajes: 247
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #4 en: 28 de Febrero de 2021, 20:16:00 »
Con el CRC8 sería la forma más rápida.

  Si tienes 4 bytes de un rfid seguido de un byte con un CRC8 calculado sobre esos 4 bytes entonces la búsqueda solo la haces en los crc8’s y no en toda la eeprom.

  Por ejemplo:

  Meten una tarjeta. Su rfid es 1234567890. ....



Gracias por tu respuesta, por ultimo antes de tirarme al ruedo,,
lo ideal seria antes de empezar a escribir el la eeprom colocar todo en FF? para saber donde escribí la ultima vez, o que seria lo adecuado para ir escribiendo en orden?
Gracias por la paciencia.
Si algo parece complicado... es por que esta mal explicado.

Desconectado Robert76

  • PIC24F
  • *****
  • Mensajes: 562
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #5 en: 28 de Febrero de 2021, 22:14:23 »
Hola, pero al trabajar con índices, no necesitas explorar la EEPROM.
Lo 1ro. qué debe hacer el programa una vez detectada una tag, es enviar el índice y esperar los datos. Sí dichos datos vuelven en FF, pues quiere decir que esa tarjeta nunca se usó.
Y ahí es dónde entra la creatividad!
Puedes gestionar arbitrariamente que datos guardar para cada tag.
Por ejem. almacenar además de los 4 octetos que requieres, añadir 1 byte más, indicando los atributos.
Es decir, si dicha tag está habilitada vale 0x01.
Sí está anulada, 0x02, suspendida 0x03, según jerarquía de lugares restringidos 0x04 al 0x20(ejem), etc.
Sí la tarjeta es eliminada, dicho byte vuelve a FF o el valor que tú deseas y bien conoces.
« Última modificación: 28 de Febrero de 2021, 22:23:48 por Robert76 »

Desconectado remi04

  • PIC24F
  • *****
  • Mensajes: 657
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #6 en: 01 de Marzo de 2021, 07:02:32 »
Con el CRC8 sería la forma más rápida.

  Si tienes 4 bytes de un rfid seguido de un byte con un CRC8 calculado sobre esos 4 bytes entonces la búsqueda solo la haces en los crc8’s y no en toda la eeprom.

  Por ejemplo:

  Meten una tarjeta. Su rfid es 1234567890. ....



Gracias por tu respuesta, por ultimo antes de tirarme al ruedo,,
lo ideal seria antes de empezar a escribir el la eeprom colocar todo en FF? para saber donde escribí la ultima vez, o que seria lo adecuado para ir escribiendo en orden?
Gracias por la paciencia.

Efectivamente la eeprom la inicializas a FF una sola vez. Por ejemplo, mediante un menú o una opción de inicialización, esto sería “formatear”

 Esto se puede plantear de muchas formas. Yo te sugiero imitar un poco a un sistema de archivos y estructurar la eeprom para trabajar de forma similar.

 
  Puedes hacerlo parecido a como funciona el sistema de archivos FAT32 que usa un sector llamado FSINFO donde almacena entre otros, cuál es la última entrada que ha sido ocupada y por lo tanto, para buscar una entrada libre lo harás a partir de la siguiente que indica fsinfo.  Pues aquí lo puedes hacer igual.  Esto FAT32 lo usa solamente para acelerar la búsqueda de entradas libres en una unidad que puede tener 32 Gb.   Se hace muy necesario. Pero en tu caso en una eeprom que puede tener 255 bytes o 2 Kb no vas a acelerar mucho, pero la idea en este caso no es acelerar nada sino controlar en forma secuencial por orden ascendente el registro y eliminación de tarjetas como explicó más abajo.

  En adelante, llamo “entrada” al conjunto de 5 bytes (4 para tu rfid y 1 para crc o byte de atributos) como sugiere el compañero que es también muy buena idea por que puedes indicar muchísimas cosas en ese byte relativos a la entrada de la que forma parte o al rfid en si o a todo.
 
 Te reservas por ejemplo la última posición o las dos últimas posiciones de la eeprom según la cantidad de eeprom disponible para poner ahí tu “fsinfo”. Cuando grabes una tarjeta nueva, te vienes aquí e indicas el índice de entrada de esa tarjeta entendiendo como índice, el que apunta al quinto byte de la entrada (que es el que contiene el crc o los atributos)  Así siempre sabes donde se grabó la última tarjeta y no tienes que escanear toda la eeprom.

 
Cuando una tarjeta es eliminada, sus 5 bytes pasan a FF.   

  Cuando vas a grabar una nueva consultas tu “fsinfo” para saber por donde se grabó la última y empezar a buscar una entrada libre para la nueva tarjeta.  Cuando fsinfo llegue al final de la eeprom empieza a cero otra vez. 

 Escanear solo los bytes 4,9,14,19 como ya sugerí. Si están en FF significa que esa entrada es posible que esté libre. Aún hay que comprobarlo.

   Ahora tocaría leer la entrada completa, los 5 bytes. ¿Están todos a FF? , entrada libre encontrada. La tomas, la usas y te vas al fsinfo y lo indicas. Ya siempre sabrás a partir de donde empezar a buscar la siguiente vez.

 Como ves, las operaciones de registro y eliminación de tarjetas siempre va a ir en forma secuencial en orden ascendente a lo largo de toda la eeprom  y cuando llegues al final comienza a cero de nuevo.

  Esto presenta de antemano una ventaja, y es que las operaciones de grabación en las entradas disponibles se automatiza. 

  Pero presenta una desventaja, y es que los índices ya no van a estar necesariamente organizados por orden.  Por lo que cuando metes una tarjeta y lees el rfid y obtienes su índice tienes que ir a buscar ese índice en la eeprom.  Escaneando de nuevo los bytes 4,9,14,19,24,29, etc de principio a fin hasta que lo encuentres.

  De nuevo, en el arranque del programa lo podrías indexar. Leyendo todos los índices y haciéndote un array en ram de donden están todos y así la localización es prácticamente instantánea.

  Un saludo.


 
« Última modificación: 01 de Marzo de 2021, 07:04:34 por remi04 »

Desconectado johenrod

  • PIC16
  • ***
  • Mensajes: 247
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #7 en: 01 de Marzo de 2021, 13:00:23 »
Gracias por las respuestas... y por el tiempo dedicado.
Uf... va a estar algo teso pero ya que no soy muy bueno con punteros, pero de eso se trata de ir aprendiendo.
según vaya realizando el código lo voy subiendo  para aceptar mejoras.
 :-)
Si algo parece complicado... es por que esta mal explicado.

Desconectado johenrod

  • PIC16
  • ***
  • Mensajes: 247
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #8 en: 15 de Marzo de 2021, 19:13:12 »
ya voy algo adelantando algo, pero me frene en un problema.
la tarjeta rfid RDM6300 125KHZ su literatura dice que tiene un código HEX que lo convierten a "ASCCI" pero al leerlo en el pic no me lee ni el primero ni el ultimo bit( el primero siempre es 2 y el ultimo siempre un 3) ,en la tabla ascci dice que son comienzo y final de texto sera por esto que no los muestra?
dejo el código que viene en la tarjeta y su representación en "ASCCI" que es lo que recibe el pic
   2,30,39,30,30,36,32,39,39,32,39,44,42,3  >esto a lo interior de la tarjeta y lo envía en ascci asi>
       0  9   0   0   6   2   9   9   2   9  D  B

   Como podría leer los 14 bits que envía la tarjeta?

en arduino lee todo con "temp=Serial.read();" pero la idea es hacerlo en ccs, gracias..
Si algo parece complicado... es por que esta mal explicado.

Desconectado remi04

  • PIC24F
  • *****
  • Mensajes: 657
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #9 en: 15 de Marzo de 2021, 20:38:17 »
Te creas un array de 14 elementos y los inicializas por ejemplo a 0xff:

Código: C
  1. char rfid[14];
  2. for(int i=0;i<14;i++) rfid[i] = 0xff;

 Ahora, como el primer valor sabes que es un “2”, pues esperas por él:

Código: C
  1. while(rfid[0] != 2) rfid[0] = getc();

Una vez recibido el 2 ya lo tienes cargado en el byte 0 del array
 
  Ahora recibes el resto hasta que te llegue el valor 3 que sabes que es el último:

Código: C
  1. int i=1;
  2. while ((rfid[i-1] != 3) && ( i<14)) rfid[i++] = getc();

 Esto te va a grabar por orden los caracteres que recibas en el array hasta que encuentre el 3 o hasta que se llene el mismo. Lo que primero suceda. Se entiende que estas seguro que siempre van a ser 14 bytes. Si no, le asignas mayor tamaño al array.

 
« Última modificación: 15 de Marzo de 2021, 20:40:41 por remi04 »

Desconectado johenrod

  • PIC16
  • ***
  • Mensajes: 247
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #10 en: 15 de Marzo de 2021, 22:00:46 »
Citar
Publicado por: remi04
« en: Hoy a las 20:38:17 »Insertar Cita
Te creas un array de 14 elementos y los inicializas por ejemplo a 0xff:

Código: C
char rfid[14];
for(int i=0;i<14;i++) rfid = 0xff;
 

 Ahora, como el primer valor sabes que es un “2”, pues esperas por él:

Código: C
while(rfid[0] != 2) rfid[0] = getc();
 

Una vez recibido el 2 ya lo tienes cargado en el byte 0 del array...
que excelente todo esto que se aprende, gracias

he tratado de hacer  el ejercicio partiendo de lo que pude entenderte, aunque no sale nada me dirías por favor como voy? Gracias..
Código: C
  1. #include <16f1827.h>
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #use delay (internal=4000000)
  5. #fuses NOPROTECT,NOWDT,nobrownout,nomclr
  6. #define TX PIN_b2
  7. #define RX PIN_b1
  8. #use rs232(baud=9600,parity=N,xmit=TX,rcv=RX,bits=8,ERRORS)
  9. #bit RXDTSEL = 0x11D.7 // 0X11D HACE REFERENCIA AL REGISTRO APFCON0 bit 7
  10. #bit TXCKSEL = 0x11E.0 // 0X11D HACE REFERENCIA AL REGISTRO APFCON1 bit 0
  11.  
  12. #USE fast_io (A)      // Optimizamos E/S del PORTB ( muy importante para ahorrar memoria )
  13. #USE fast_io (B)
  14. #BYTE porta= 0X0C
  15. #BYTE portb= 0X0D
  16. //#define LED PIN_B0
  17.  
  18.  
  19.  
  20. // ******* variable globales ********
  21.  
  22.  
  23. // INTERRUPCIONES : RDA Recepción USART
  24. ///////////////////////////////////////////////////////////////////////////////////////////////////
  25.  
  26.    void main()
  27.    {
  28.    RXDTSEL=0;// PIN CON VARIAS FUNCIONES EN 0 FUNCIONA COMO RX
  29.    TXCKSEL=0; // PIN CON VARIAS FUNCIONES EN 0 FUNCIONA COMO TX
  30.    //setup_adc_ports(NO_ANALOGS);
  31.    set_tris_b(0b00000010);
  32.    output_B(0x00);
  33.  
  34.     char rfid[14];
  35.     printf("estoy transmitiendo");
  36.    
  37.    while(TRUE);
  38.    {
  39.  
  40.    for   (int i=0;i<14;i++) // aqui coloco todas las posiciones del array en 255 (del 0 al 13)
  41.          {
  42.          rfid[i] = 0xff;  //no se por que hay que iniciarlas
  43.          }
  44.    
  45.    while(rfid[0] != 2) // mientras que la posicion 0 del array sea diferente a 2 vuelva a preguntar
  46.          {
  47.          rfid[0] = getc();
  48.          }
  49.    
  50.    // si pasa aqui es por que la poscicion 0 ya es un 2
  51.    
  52.    int j=1;  // aqui cambie la variable por j por que sale un error que ya se esta usando en el for
  53.    while ((rfid[j-1] != 3) && ( j<14)) // como j es 1 -1 ya j es 0 y diferente a 3 y menor que 14
  54.    {
  55.    rfid[j++] = getc(); // si se cumple, incremento posicion del array en 1 y grabo el siguiente dato
  56.    }
  57.    
  58.    printf("cadena%s",rfid);// aqui no me sale nada en el monitor
  59.  
  60.  
  61.    
  62.    }
Si algo parece complicado... es por que esta mal explicado.

Desconectado remi04

  • PIC24F
  • *****
  • Mensajes: 657
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #11 en: 16 de Marzo de 2021, 19:32:48 »
Puedes ir poniendo print’s en varios sitios para que puedas ir viendo a donde llega y a donde no.  Así vemos donde se nos queda.

 Dos cosas:

   Siempre me gusta inicializar todas las variables que uso en un programa, incluidos los array.  Me parece una buena práctica y te puede evitar problemas.

    Lo otro es que el uso del ++ en una variable es un preincremento si la precede o un postincremento si la sigue. En el caso de :
rfid[j++] = getc();

 primero lee, asigna y luego incrementa, no al revés como has descrito.
 Para que incremente primero y luego asigne sería ++j y no j++

  Por otro lado,

   ¿Como sabes que el módulo te envía solo esos 14 bytes?.  ¿Lo has podido ver en un terminal?.  Si es así, haz una cosa, pon el terminal en modo hexadecimal, y captura una trama entera del módulo rfid. Ponme aquí mismo la trama en hex.  Olvídate de ascii que no aparecen los caracteres de control entre otros, pero en hex aparece absolutamente todo.

 Saludos.


Desconectado johenrod

  • PIC16
  • ***
  • Mensajes: 247
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #12 en: 16 de Marzo de 2021, 20:59:14 »
Citar
remi04
Gracias valoro tu tiempo..
la captura lo muestra varias veces porque aun no implemento detener la lectura cuando llena el buffer,,,(pero eso ya lo sabes!)
en el siguiente fragmento de codigo , que significa  o porque  -1
Código: C
  1. int ssvalue = ssrfid.read(); // read  // almaceno el dato entrante en ssvalue
  2.     if (ssvalue == -1) { // no data was read  
  3.       return;

 

* trama.png
(188.76 kB, 831x713 - visto 323 veces)



« Última modificación: 16 de Marzo de 2021, 23:28:30 por johenrod »
Si algo parece complicado... es por que esta mal explicado.

Desconectado remi04

  • PIC24F
  • *****
  • Mensajes: 657
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #13 en: 17 de Marzo de 2021, 04:56:04 »
Está preguntando si ssvalue contiene el valor 0xff.   (Por eso hay que inicializarlas).  Y por lo tanto, no contendría un valor válido.

  El tipo int por si solo puede tener signo en complemento a 2. El -1 es lo mismo que 0xff

 Por otro lado , al mirar la captura de realterm en ascii puro, lo cambia todo.

 Parece que el módulo te está leyendo la rfid de una tarjeta y te lo está convirtiendo a ascii puro imprimible para que puedas imprimir ese rfid en un terminal, monitor, etc directamente por rs232.


  Esto a la hora de recibirlo e interpretarlo con un pic lo tienes que tener en cuenta por que todo cambia. Absolutamente todo. 

Para empezar, del módulo estás recibiendo 28 bytes por trama y no 14 como creías. 

  El número entero “2” en ASCII sería (inicio de texto) te lo está enviando directamente en caracteres  imprimibles ascii, y no solo eso, sino que te envía 02. Lo cual son dos caracteres, un 0 y un 2.   Lo mismo pasa con el “3” del final. No es un 3, es un 0 y un 3, es decir otros dos caracteres.

 Es normal que no funcione el programa por que estabamos esperando por el número 2 entero, sin embargo el módulo está enviando “02” eso son dos caracteres ASCII, el ‘0’ que equivale al entero 48 (0x30) en hexadecimal, y el ‘2’ que equivale al entero 50 (0x32).   

   En el programa entonces no podemos esperar por el 2, tenemos que esperar por el 0x30 y por el 0x32 de forma consecutivas (2 bytes).  Una vez recibidos estos dos caracteres recibes el cuerpo del rfid que son 24 bytes y por último recibes el fin de texto que sería, de nuevo 0, (0x30) seguido en este caso del 3, (0x33). Otros dos bytes. 28 en total.

  Hay una función que sirve para convertir Un carácter ascii en su valor entero atoi();. No se si la implementa CCS, de cualquier modo es muy fácil, simplemente al carácter ascii que recibas le restas 48 y te queda su entero equivalente. 

 Ejemplo: el ascii 0, su entero equivalente es 48.
 int minumero_ascii_en_entero = 48 - 48   //  te daria 0.

  Para el 1:     49 - 48 = 1.

  En base a todo esto es fácil modificar el programa.  Tienes que cambiar el tamaño del array y el bucle de espera que ahora son dos caracteres a detectar antes de capturar trama.

 Saludos.

 Un saludo.
 

« Última modificación: 17 de Marzo de 2021, 05:28:10 por remi04 »

Desconectado johenrod

  • PIC16
  • ***
  • Mensajes: 247
Re:como almacenar 32 bits en EEPROM y saber la próxima posición de escritura?
« Respuesta #14 en: 17 de Marzo de 2021, 22:23:27 »
Citar
Publicado por: remi04
« en: Hoy a las 04:56:04 »

Está preguntando si ssvalue contiene el valor 0xff.   (Por eso hay que inicializarlas).  Y por lo tanto, no contendría un valor válido.

  El tipo int por si solo puede tener signo en complemento a 2. El -1 es lo mismo que 0xff

 Por otro lado , al mirar la captura de realterm en ascii puro, lo cambia todo.
gracias  de nuevo por tu tiempo..
creo que me falta colocar informacion por que con tu respueta de 28 bits me confundi mas,, ya que mirandolo desde tu perspectiva veo que tienes la razon son 28 bits,  en los ejemplos que he podido investigar dice que la tarjeta maneja los datos en "HEX" pero al momento de transmitirlos los codifica a "ASCII" y ahí es donde veo se reducen los bytes a 14.
te dejo la imagen que podria aclarar dudas, en el pantallazo que te envie antes lo capture en "HEX" agregare la captura en "ASCCI"








« Última modificación: 17 de Marzo de 2021, 23:09:21 por johenrod »
Si algo parece complicado... es por que esta mal explicado.


 

anything