# Recebendo dados de tempo de passagem durante uma sessão Assim que uma **sessão de cronometragem** é iniciada enviando o comando `START` para o CloudBox, a conexão TCP deve permanecer aberta para receber continuamente fluxos de dados de cronometragem em tempo real, conhecidos como **passagens**. Cada passagem representa uma instância de uma etiqueta RFID sendo detectada pelo sistema e contém informações importantes sobre o atleta ou objeto que acionou a leitura RFID. Os **dados de passagem** são enviados ao cliente conectado no formato JSON, com a seguinte estrutura: ```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-chave de uma aprovação 1. **epc** (Código Eletrônico de Produto)(*): Este é o identificador exclusivo da etiqueta RFID que foi detectada. O EPC ajuda a identificar qual etiqueta específica foi lida durante a sessão. 2. **timestamp**: A hora exata em que a passagem foi registrada, fornecida no formato ISO 8601 (`YYYY-MM-DDTHH:mm:ss.sssZ`). Isso permite o rastreamento preciso do momento em que a etiqueta foi detectada. 3. **seenCount** (*): O número de vezes que esta etiqueta foi detetada no mesmo ciclo de leitura. Este valor pode ajudar a determinar a proximidade ou a qualidade da leitura da etiqueta. 4. **antena** (*): Identifica qual antena detectou a etiqueta. Em sistemas com várias antenas, isso ajuda a determinar em qual parte do percurso ou ponto de controle a passagem ocorreu. 5. **rssi** (*): O **Indicador de Força do Sinal Recebido (RSSI)** mede a força do sinal recebido da etiqueta RFID. Esse valor pode ajudar a determinar a proximidade ou a qualidade da leitura da etiqueta. 6. **passingNumber**: Um número sequencial que é incrementado a cada passagem, fornecendo um identificador exclusivo para cada evento de passagem durante a sessão de cronometragem. 7. **tagStr** (*): Uma representação de string da etiqueta extraída do código `epc`. Dados disponíveis ao ler etiquetas codificadas RUFUS. 8. **latitude** (*): As coordenadas de latitude do dispositivo GPS (se disponíveis). Esse valor pode ajudar a rastrear a localização exata da passagem em um mapa global. 9. **longitude** (*): As coordenadas de longitude do dispositivo GPS (se disponíveis). Este valor, juntamente com a latitude, fornece a localização geográfica da passagem. 10. **chksum**: O checksum é usado para verificar a integridade dos dados, garantindo que os dados transmitidos foram transmitidos corretamente e sem erros. *(*) As informações podem não estar disponíveis dependendo do leitor RFID instalado ou da configuração do CloudBox. As chaves estarão sempre presentes e, se não houver dados disponíveis, o valor será nulo.* ## Lidando com a passagem de dados Assim que o comando `START` for emitido e a sessão estiver ativa, as passagens serão enviadas pela **mesma conexão TCP aberta** para os clientes conectados. Cada passagem é transmitida como um objeto JSON separado, semelhante ao exemplo fornecido acima. As passagens continuam a ser transmitidas em tempo real à medida que atletas ou objetos com etiquetas RFID passam pelas antenas de deteção. O formato de cada passagem é consistente, permitindo que o sistema receptor analise e processe os dados para fins de temporização, classificação e rastreamento. O aplicativo cliente precisa lidar com o fluxo contínuo de passagens analisando os dados de entrada, processando-os e armazenando-os conforme necessário. Abaixo estão exemplos em Python, C# e Node.js para lidar com as passagens de entrada. #### Exemplo em 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.) ``` #### Exemplo em 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}"); } } } ``` **Exemplo 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}`); }); ``` ## Conclusão Assim que uma sessão de cronometragem é iniciada, o CloudBox envia fluxos de passagens pela conexão TCP aberta em tempo real, cada um contendo dados vitais de detecção RFID. Você pode lidar com essas passagens em Python, C# ou Node.js, dependendo das necessidades do seu aplicativo. As passagens podem então ser processadas para armazenamento, análise e operações de cronometragem de corrida.