Cómo crear un extensor de rango Ble-wifi para T-skin

Introducción
¡Hola! Este proyecto está diseñado para ilustrar la ampliación de las capacidades de comunicación de Tactigon Skin (T-Skin). Queremos poder usarlo en distancias más largas que las que ofrece Bluetooth Low Energy. Planeamos transmitir datos desde el T-Skin a una computadora personal a través de WiFi con una Raspberry Pi Zero W que emplea el protocolo UDP. Se utilizó un NodeMCU con un módulo BLE para proporcionar al Tactigon Skin la capacidad de transmitir mediante WiFi.

Arquitectura de hardware
Utilizamos mucho hardware en este proyecto, por lo que pensamos que una imagen puede ayudar a mantener las cosas en su mente.
El Tactigon Skin no admite de forma nativa la comunicación WiFi. Superamos esta limitación transmitiendo datos a la Raspberry Pi (RPi) con un NodeMCU con un módulo BLE. Utilizamos una red privada alojada por Raspberry. Esto elimina la necesidad de acceder a las redes públicas, ya que el RPi se utiliza como punto de acceso a la red.
Para aprender a configurar el RPi como punto de acceso, siga este enlace: Configure Access Point Mode

Arquitectura de software
Ahora que la infraestructura de nuestro proyecto está definida, veamos cómo funcionan los componentes.
BLE al nodo UDP
BLE al nodo UDPEl T-Skin recopila datos de sus sensores, como sus acelerómetros y giroscopios. La información se utiliza para crear un paquete para su transmisión a NodeMCU a través de BLE.

T-Skin recopila los datos usando este código:
T_QUAT qMeter; T_QData qData; qData = qMeter.getQs(); roll = radToDegree(qData.roll - rollZero); pitch = radToDegree(qData.pitch - pitchZero); yaw = radToDegree(qData.yaw - yawZero);Primero, se definen las variables qMeter y qData. Estos objetos se crean utilizando las clases T_QUAT y T_QData. Estas variables contendrán los datos de los cuaterniones del giroscopio. La lectura de datos se realiza con la instrucción qMeter.getQs (). Luego usamos variables separadas para almacenar los valores de balanceo, cabeceo y guiñada.
Luego, el protocolo de comunicación UDP se usa para enviar los datos al Raspberry Pi Zero W.
WiFiUDP Udp; unsigned int UDP_Port = 5000; char* UDP_IP = "192.168.4.1"; char PacketBuffer[1024]; Udp.beginPacket(UDP_IP, UDP_Port); Udp.write(PacketBuffer); Udp.endPacket();Cuando se recibe un paquete de datos completo, se usa para crear un paquete UDP para la transmisión. Después de definir el puerto y la dirección IP del receptor, los datos se escriben en la línea y el procedimiento de envío de paquetes finaliza.
Hemos configurado NodeMCU para que intente volver a conectarse lo antes posible en caso de que falle la conexión.
UDP a VCOM
En nuestro escenario, tenemos la Raspberry Pi configurada para ser un dispositivo Gadget. Esto permite que una PC lo identifique como un dispositivo de puerto serie para activar la comunicación. Puede aprender cómo configurar el dispositivo de la misma manera en este enlace: Serial Gadget Mode Configuration.
Una secuencia de comandos de Python que se ejecuta continuamente toma los paquetes UDP y los envía al puerto serie virtual de Raspberry Pi. Si ejecuta un programa de monitor de puerto serie para interrogar el puerto COM en la PC, puede ver la secuencia de datos recopilada por el Tactigon Skin.
Aquí hay un ejemplo de este sistema en acción:

Conclusiones
Consideramos que este proyecto fue un éxito ya que logramos nuestro objetivo y pudimos usar el Tactigon Skin en distancias considerablemente más largas. Mediante la transmisión WiFi, pudimos aumentar el rango de comunicación de tres o cuatro metros a más de 40 metros. Toda una diferencia!
Tendrá dos limitaciones principales cuando implemente la comunicación con este método. Primero está la interferencia potencial de otras señales que usan la banda de 2.4 GHz. El alcance máximo de la antena Wi-Fi Raspberry Pi Zero W es el segundo factor limitante. Se pueden usar protocolos LPWAN alternativos como LoRa y SigFox para minimizar los problemas de señal que pueden surgir.
Una vez que se han superado las limitaciones de distancia del T-Skin, el dispositivo se vuelve capaz de un nivel de funcionalidad mucho mayor. Se puede usar para controlar dispositivos de robot de forma remota para su uso en misiones de búsqueda y rescate posteriores al desastre o para ayudar a equipos de demolición sin arriesgar vidas humanas.

Código
RPi_Tactigon_Extender.py
Este código se ejecutará automáticamente al arrancar el Raspberry Pi Zero W.

1.  #!/usr/bin/env python
2. #UDP SERVER CODE
3. #To run this script at boot you have te add the following to the /etc/rc.local file in sudo mode
4. #sudo python /path_to_this_script/script_name.py
5. #before the exit 0 directive
6. import os
7. import sys
8. import socket
9. import serial
10. import time
11. 
    
12. UDP_PORT = 5000
13. UDP_IP = '192.168.4.1' #IP address of the machine to whick this script will run
14. #small delay to ensure that everithing started up
15. time.sleep(10)
16. 
    
17. port = serial.Serial("/dev/ttyGS0", baudrate=115200, timeout=0.1)
18. 
    
19. sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
20. sock.bind((UDP_IP, UDP_PORT))
21. 
    
22. while ((port.in_waiting) <= 0):
23. data, addr = sock.recvfrom(1024) #store received data
24. #print(data) #for debug
25. port.write(data + '\n') #write received data from UDP to the emulated serial port
26. #if the input buffer of the serial port is NOT empty that means that the shutdown command has been received from the PC
27. os.system("shutdown now -h")

BLEtoUDP.ino
Este código se muestra en el NodeMCU.

1.  //SENDER
2. #include
3. #include
4. 
   
5. //UDP handle
6. WiFiUDP Udp;
7. unsigned int UDP_Port = 5000;
8. char* UDP_IP = "192.168.4.1"; //IP address of the RECEIVER
9. char PacketBuffer[1024]; //Buffer used for UDP data
10. 
    
11. //Wifi handle
12. const char* ssid = "YOUR_SSID";
13. const char* password = "YOUR_PASSWORD";
14. IPAddress ip(192, 168, 4, 2); //set a static IP for this device
15. IPAddress gateway(192, 168, 4, 1);
16. IPAddress subnet(255, 255, 255, 0);
17. 
    
18. bool flag = false; //to handle complete read of BLE data
19. int count = 0; //counter for checking correct length of received buffer from BLE, starts from 0 to 19
20. 
    
21. void setup() {
22.     memset(&PacketBuffer, (char)0, 1024); //set all buffer to 0
23.     pinMode(LED_BUILTIN, OUTPUT); //LOW = WiFi connected; HIGH = WiFi not connected
24.     digitalWrite(LED_BUILTIN, HIGH);
25.     Serial.begin(115200); //BLE serial
26.     WiFi.config(ip, gateway, subnet);
27.     WiFi.mode(WIFI_STA); //station mode
28.     WiFi.begin(ssid, password);
29.     Serial.println();
30.     Serial.print("Wait for WiFi");
31.     //wait for wireless connection
32.     while (WiFi.status() != WL_CONNECTED) {
33.         delay(500);
34.         Serial.print(".");
35.     }
36.     digitalWrite(LED_BUILTIN, LOW);
37.     Serial.println("");
38.     Serial.println("WiFi connected");
39.     Serial.println("IP address: " + WiFi.localIP().toString());
40.     Serial.println();
41.     Udp.begin(UDP_Port); //initialize UDP
42. }
43. 
    
44. void loop() {
45.     //if wireless connection drops, try to reconnect to it
46.     while (WiFi.status() != WL_CONNECTED) {
47.         digitalWrite(LED_BUILTIN, HIGH);
48.         delay(500);
49.         Serial.print(".");
50.     }
51. 
    
52.     digitalWrite(LED_BUILTIN, LOW);
53.     if (Serial.available()) {
54.         //read one char at the time and store it to che progressive 'count' position in the buffer array
55.         Serial.read(&PacketBuffer[count], 1);
56.         //checking for carriage return and line feed chars
57.         //replace carriage return (if for any reasons is present) with whitespace to avoid complications in the buffer processing by the receiver
58.         if (PacketBuffer[count] == '\r') PacketBuffer[count] = ' ';
59.         else if (PacketBuffer[count] == '\n') {
60.             //at this point the one buffer from BLE serial is completely processed
61.             PacketBuffer[count] = (char)0;
62.             count = 0; //reset counter
63.             flag = true; //complete data
64.         }
65.         else {
66.             //increment counter for next char read
67.             count++;
68.         }
69.     }
70. 
    
71.     if (flag) {
72.         //start send data from [1] and not [0] due to how data is sent by the T-skin.
73.         //the data in [0] is treated by a serial read as a terminator char (char)0.
74.         //if this data ends up in the buffer that we send the calid data after that char will be ignored
75.         //sending data from 2nd element is less time consuming that shifting all buffer
76.         //Serial.println(&PacketBuffer[1]); //for debug
77.         //here we send via UDP the data from BLE
78.         Udp.beginPacket(UDP_IP, UDP_Port);
79.         Udp.write(&PacketBuffer[1]);
80.         Udp.endPacket();
81.         flag = false; //reset flag for next buffer
82.         memset(PacketBuffer, (char)0, 1024); //set all buffer to 0
83.     }
84. }