# Recepción de datos de tiempo de los pases durante una sesión Una vez que se inicia una **sesión de cronometraje** enviando el comando `START` a la CloudBox, la conexión TCP debe permanecer abierta para recibir continuamente flujos de datos de cronometraje en tiempo real, conocidos como **pasos**. Cada paso representa una instancia de una etiqueta RFID detectada por el sistema y contiene información importante sobre el atleta u objeto que activó la lectura RFID. Los **datos de aprobación** se envían al cliente conectado en formato JSON, con la siguiente estructura: ```json { "epc": "EPC_CODE_HERE", "timestamp": "2024-09-17;14:34:23.123Z", "seenCount": 3, "antenna": 1, "rssi": -65, "passingNumber": 145, "tagStr": "TAG_STRING", "latitude": 41.28425, "longitude": 1.98251, "chksum": "CHECKSUM_HERE" } ``` ## Elementos clave de un pase 1. **epc** (Código de producto electrónico)(*): Este es el identificador único de la etiqueta RFID que se detectó. El EPC ayuda a identificar qué etiqueta específica se leyó durante la sesión. 2. **timestamp**: La hora exacta en que se registró el paso, proporcionada en formato ISO 8601 (`YYYY-MM-DDTHH:mm:ss.sssZ`). Esto permite un seguimiento preciso del momento en que se detectó la etiqueta. 3. **seenCount** (*): El número de veces que se ha detectado esta etiqueta dentro del mismo ciclo de lectura. Este valor puede ayudar a determinar la proximidad o la calidad de la lectura de la etiqueta. 4. **Antena** (*): Identifica qué antena detectó la etiqueta. En los sistemas con varias antenas, esto ayuda a determinar en qué parte del recorrido o punto de control se produjo el paso. 5. **rssi** (*): El **indicador de intensidad de señal recibida (RSSI)** mide la intensidad de la señal recibida de la etiqueta RFID. Este valor puede ayudar a determinar la proximidad o la calidad de la lectura de la etiqueta. 6. **passingNumber**: Un número secuencial que se incrementa con cada pasada, lo que proporciona un identificador único para cada evento de pasada durante la sesión de cronometraje. 7. **tagStr** (*): Una representación de cadena de la etiqueta extraída del código `epc`. Datos disponibles al leer etiquetas codificadas RUFUS. 8. **latitud** (*): Las coordenadas de latitud del dispositivo GPS (si están disponibles). Este valor puede ayudar a rastrear la ubicación exacta del paso en un mapa global. 9. **longitud** (*): Las coordenadas de longitud del dispositivo GPS (si están disponibles). Este valor, junto con la latitud, proporciona la ubicación geográfica del paso. 10. **chksum**: La suma de comprobación se utiliza para verificar la integridad de los datos, lo que garantiza que los datos transmitidos se hayan enviado correctamente y sin errores. *(*) La información puede no estar disponible dependiendo del lector RFID instalado o de la configuración de CloudBox. Las claves siempre estarán presentes y si no hay datos disponibles, el valor será nulo.* ## Manejo de los datos que se pasan Una vez que se emite el comando `START` y la sesión está activa, los pases se envían a través de la **misma conexión TCP abierta** a los clientes conectados. Cada pase se transmite como un objeto JSON independiente, similar al ejemplo proporcionado anteriormente. Los pases continúan transmitiéndose en tiempo real a medida que los atletas u objetos con etiquetas RFID pasan por las antenas de detección. El formato de cada pase es consistente, lo que permite al sistema receptor analizar y procesar los datos para fines de sincronización, clasificación y seguimiento. La aplicación cliente debe gestionar el flujo continuo de pases analizando los datos entrantes, procesándolos y almacenándolos según sea necesario. A continuación, se muestran ejemplos en Python, C# y Node.js para gestionar los pases entrantes. #### Ejemplo de Python ```python import json HOST = '192.168.1.10' PORT = 8080 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) s.sendall("START\r\n".encode('utf-8')) # Start the timing session while True: data = s.recv(1024) if data: passing = json.loads(data.decode('utf-8')) print(f"Passing received: {passing}") # Process the passing data here (e.g., save to database, analyze, etc.) ``` #### Ejemplo en C# ```csharp using System; using System.Net.Sockets; using System.Text; using Newtonsoft.Json.Linq; // Install via NuGet class Program { static void Main(string[] args) { string host = "192.168.1.10"; int port = 8080; try { TcpClient client = new TcpClient(host, port); NetworkStream stream = client.GetStream(); byte[] startCommand = Encoding.ASCII.GetBytes("START\r\n"); stream.Write(startCommand, 0, startCommand.Length); byte[] buffer = new byte[1024]; while (true) { int bytesRead = stream.Read(buffer, 0, buffer.Length); if (bytesRead > 0) { string passingData = Encoding.ASCII.GetString(buffer, 0, bytesRead); JObject passing = JObject.Parse(passingData); Console.WriteLine($"Passing received: {passing}"); // Process the passing data (e.g., save to database, analyze, etc.) } } stream.Close(); client.Close(); } catch (Exception e) { Console.WriteLine($"Error: {e.Message}"); } } } ``` **Ejemplo de Node.js** ```javascript const net = require('net'); // CloudBox IP and port const HOST = '192.168.1.10'; const PORT = 8080; // Create a socket connection to CloudBox const client = new net.Socket(); client.connect(PORT, HOST, () => { console.log(`Connected to CloudBox at ${HOST}:${PORT}`); // Send the START command to initiate timing session client.write("START\r\n"); }); // Receive and process passings client.on('data', (data) => { const passing = JSON.parse(data.toString()); console.log(`Passing received: ${JSON.stringify(passing)}`); // Process the passing data (e.g., save to database, analyze, etc.) }); // Handle connection close client.on('close', () => { console.log('Connection closed'); }); // Handle errors client.on('error', (err) => { console.error(`Error: ${err.message}`); }); ``` ## Conclusión Una vez iniciada una sesión de cronometraje, la CloudBox envía flujos de pasadas a través de la conexión TCP abierta en tiempo real, cada uno de los cuales contiene datos de detección vitales de RFID. Puede gestionar estas pasadas en Python, C# o Node.js, en función de las necesidades de su aplicación. Las pasadas pueden procesarse para su almacenamiento, análisis y operaciones de cronometraje de carreras.