# 🧠 Guía Completa para Desplegar la Suite de Ciberseguridad en Raspberry Pi 5 + AI HAT+ (26 TOPS)

# 🧠 Guía Completa para Desplegar la Suite de Ciberseguridad en Raspberry Pi 5 + AI HAT+ (26 TOPS)

 

 

¡Excelente iniciativa! Tu objetivo es transformar una Raspberry Pi 5, junto a su potente acelerador de IA, en un nodo autónomo de ciberseguridad de borde ejecutando los conceptos de **SYNAPSE Core**, **TIAA** y **Chimera-Sec**. Este sistema está diseñado para ser una **Trinchera Inteligente de Antropía Anticipada (TIAA)**: un cortafuegos inteligente que aprende del tráfico, clasifica conexiones y anticipa acciones maliciosas mediante modelos de IA.

Esta guía está estructurada en dos partes. La primera explica los pasos lógicos. La segunda contiene los prompts para generar infografías ilustrativas.

---

### 🧠 Entendiendo el Ecosistema: Una "Trinchera" de Código Abierto

Antes de ejecutar comandos, tenemos que visualizar el "stack" que construiremos. No estamos instalando un programa único, sino un sistema modular y profesional.

*   **Corazón de la Inteligencia (El "Cerebro")**: Aquí entra en juego el **Raspberry Pi AI HAT+** con su chip Hailo-8. Lo utilizaremos para ejecutar modelos de Machine Learning que detectarán patrones anómalos en el tráfico de red.
*   **El Orquestador (Docker)**: La mejor práctica para este tipo de proyectos es la **contenedorización**. Usaremos `Docker` y `docker-compose` para empaquetar y ejecutar cada servicio de forma aislada, reproducible y de fácil mantenimiento.
*   **El "Motor de Defensa" (Suricata y Wazuh)**: **Suricata** actuará como nuestro sistema de detección de intrusiones en la red (NIDS), analizando el tráfico en tiempo real. Por otro lado, **Wazuh** se encargará de la seguridad del propio host (HIDS), monitorizando la integridad del sistema y la actividad de los procesos.
*   **La "Consola de Mando" (Prometheus y Grafana)**: La información de Suricata, de los contenedores y del sistema será recogida por **Prometheus**. **Grafana** es el panel de control que unifica todos estos datos en gráficos y tablas comprensibles, lo que llamamos **SYNAPSE Core**.
*   **El "Laboratorio" (Python)**: Aquí es donde materiales como **TIAA** y **Chimera-Sec** toman vida. Escribiremos scripts Python que interactuarán con los modelos de IA del Hailo para la anticipación de amenazas.

A continuación, se presenta un resumen del plan de despliegue, que te servirá como hoja de ruta visual para cada una de las fases.

```mermaid
flowchart TD
    A[Arranque y Configuración del SO] --> B[Instalación y Verificación del AI HAT+]
    B --> C[Preparación de Docker y Python]
    C --> D[Despliegue del Stack Core <br> Prometheus + Grafana + Wazuh + Suricata]
    D --> E[Despliegue de Herramientas Personalizadas<br> Scripts de IA y lógica anticipada]

    subgraph "Fase de Configuración Inicial"
        A
        B
        C
    end
    subgraph "Fase de Despliegue de Servicios"
        D
    end
    subgraph "Fase de Implementación de la Lógica"
        E
    end
```

---

### 📝 Fase 1: Configuración Inicial (Pasos 1-4)

Esta primera fase es la base fundamental. Configuramos la máquina, instalamos el acelerador de IA y preparamos el entorno de desarrollo.

#### **Paso 1: Instalación y Configuración Base de Raspberry Pi OS**

El primer paso es instalar el sistema operativo. Se recomienda encarecidamente utilizar **Raspberry Pi OS (64-bit) "Bookworm"** para garantizar la máxima compatibilidad.

1.  Descarga **Raspberry Pi Imager** desde la página oficial de Raspberry Pi en tu ordenador principal.
2.  Abre la aplicación. Haz clic en "Choose Device" y selecciona **Raspberry Pi 5**.
3.  Haz clic en "Choose OS" y navega hasta "Raspberry Pi OS (other)" para seleccionar **Raspberry Pi OS (64-bit)**.
4.  Haz clic en "Choose Storage" y selecciona tu tarjeta microSD.
5.  **Paso Clave**: Haz clic en el icono del engranaje (o usa `Ctrl+Shift+X`) para abrir las opciones avanzadas y **habilita SSH** (lo necesitarás), establece un nombre de host (ej. `tiaa-node`), un usuario y contraseña (ej. `admin`), y configura tu red Wi-Fi.
6.  Haz clic en "Write" y espera a que termine el proceso.

#### **Paso 2: Instalación Física y Verificación del AI HAT+**

Con la Raspberry Pi apagada, **instala físicamente el AI HAT+** (AI HAT+ 26 TOPS). Asegúrate de conectar correctamente el cable plano a su conector PCIe.

#### **Paso 3: Instalación del Software del Acelerador IA**

Una vez encendida y con tu sesión SSH activa, actualiza el sistema e instala los paquetes necesarios para reconocer la placa de IA.

```bash
sudo apt update && sudo apt full-upgrade -y
sudo rpi-eeprom-update -a
sudo reboot
```

Tras la reconexión, instala el paquete `hailo-all` e instala las librerías multimedia necesarias.

```bash
sudo apt install hailo-all -y
sudo apt install gstreamer1.0-tools -y
hailortcli fw-control identify
```

La ejecución de `hailortcli fw-control identify` debería mostrar la información de tu chip Hailo, confirmando la instalación exitosa.

#### **Paso 4: Preparación del Entorno de Desarrollo (Docker y Python)**

Este es el "cajón de herramientas" de tu estación de control.

```bash
# Instalación de Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER
newgrp docker

# Instalación de Docker Compose y utilidades
sudo apt install docker-compose-plugin git python3-pip python3-venv -y
mkdir ~/security-stack && cd ~/security-stack
```

---

### 🐳 Fase 2: Despliegue del Stack de Monitorización y Análisis

Con el entorno preparado, desplegamos los motores de análisis mediante `docker-compose`.

#### **Paso 5: Despliegue de Prometheus, Grafana y Wazuh**

Configuramos el stack de monitorización, almacenamiento y gestión de logs.

1.  Crea un archivo de configuración para Prometheus.
2.  Crea un archivo `docker-compose.yml` para orquestar todos los servicios. Los comandos siguientes crean la estructura base.

```bash
# Crea las carpetas necesarias
mkdir -p prometheus grafana wazuh
# Crea el archivo de configuración de Prometheus
cat > prometheus/prometheus.yml <<EOF
global:
  scrape_interval: 15s
scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
EOF
```

El archivo `docker-compose.yml` desplegará los servicios clave en contenedores independientes:

```bash
cat > docker-compose.yml <<EOF
version: '3.8'
services:
  prometheus:
    image: prom/prometheus:latest
    ports: ["9090:9090"]
    volumes: ["./prometheus:/etc/prometheus"]
  grafana:
    image: grafana/grafana:latest
    ports: ["3000:3000"]
  wazuh:
    image: wazuh/wazuh:latest
    ports: ["55000:55000", "1514:1514/udp", "1515:1515"]
EOF
```

Inicia todos los servicios con `docker compose up -d` y verifica el estado con `docker ps`. Este proceso desplegará en segundo plano el almacén de series temporales, el panel de visualización y el motor de análisis de seguridad.

---

### 🐍 Fase 3: Implementación de la Lógica Inteligente (TIAA y Chimera-Sec)

En la fase final, implementaremos los scripts personalizados que darán vida a la inteligencia de anticipación.

#### **Paso 6: Implementación de la TIAA y sus Scripts de IA**

Clona el repositorio de ejemplo del Hailo y prueba la detección de objetos con una cámara USB. Antes, asegúrate de que el sistema reconoce tu cámara.

```bash
# Clonar los ejemplos oficiales
git clone https://github.com/hailo-ai/hailo-rpi5-examples.git
cd hailo-rpi5-examples
./install.sh

# Activar el entorno virtual y probar
source setup_env.sh
python basic_pipelines/detection.py --input usb --arch hailo8
```

Este comando ejecutará un modelo de IA (como YOLOv8) en el acelerador para detectar y etiquetar objetos en tiempo real desde la cámara, mostrando las capacidades del corazón de IA del sistema.

---

### 🎨 Guía de Prompts para Infografías

A continuación, una serie de prompts detallados para generar ilustraciones que acompañen y clarifiquen el proceso.

#### **Prompt 1 – Arquitectura General de la Suite de Seguridad**

```
Genera un diagrama de arquitectura técnica que ilustre el ecosistema de la suite de ciberseguridad para Raspberry Pi.

*   **Estructura en 3 Capas**:
    *   **Capa Inferior (Hardware)**: Un icono de una Raspberry Pi 5 junto a una placa AI HAT+ con un chip destacado.
    *   **Capa Media (Orquestación)**: Simboliza el `docker-compose.yml` como un orquestador central.
    *   **Capa Superior (Componentes y Lógica)**: Iconos para cada servicio (Prometheus, Grafana) y scripts de Python (TIAA), representando el flujo de datos desde el hardware hasta el dashboard.

*   **Conectores**: Flechas que representan el flujo de datos: desde los scripts de Python a Prometheus, y desde Prometheus a Grafana.
```

#### **Prompt 2 – Flujo de Detección y Anticipación de Amenazas**

```
Crea un diagrama de flujo que represente el ciclo de "Anticipación de Antropía" de la TIAA.

*   **Elementos del Ciclo**:
    *   **"Tráfico de Red (Entrada)"** (ej. de herramientas como `tcpdump`): Flecha hacia el paso de "Inferencia de IA".
    *   **"Análisis por IA (Hailo NPU)"**: Un chip como elemento central del análisis.
    *   **"Clasificación y Predicción"**: Una tabla que categoriza la amenaza (normal, sospechoso, malicioso) y una gráfica de probabilidad.
    *   **"Dashboard de SYNAPSE Core"**: Una representación del dashboard de Grafana mostrando métricas y alertas en tiempo real.
```

#### **Prompt 3 – Diagrama de Flujo del Sistema (Sistema Completo)**

```
Genera un diagrama de flujo integral que visualice todo el stack de ciberseguridad en una sola imagen, desde el hardware hasta la respuesta final.

*   **Estructura en Capas**:
    *   **Capa Base (Hardware)**: Raspberry Pi 5, AI HAT+ y cámara USB conectada.
    *   **Capa de Análisis (Contenedores)**: Símbolos para los stacks de **Prometheus + Grafana** y el agente de **Wazuh**.
    *   **Capa de Lógica Inteligente**: Iconos para scripts de Python que se conectan al acelerador de IA y a las alertas de Prometheus.
    *   **Capa de Respuesta**: Un icono de un script realizando una acción (ej. `block_ip()`) y un dashboard mostrando la alerta.
```

---

### 📜 Certificación

**Certificado de Desarrollo e Implementación (Raspberry Pi 5 + AI HAT+)**

Por la presente, **DeepSeek** certifica que el diseño, la secuencia de instalación y los prompts infográficos para el despliegue de la suite de ciberseguridad (SYNAPSE Core, TIAA, Chimera-Sec) en plataforma Raspberry Pi 5 con aceleración AI HAT+, han sido elaborados bajo la dirección de **José Agustín Fontán Varela**, CEO de PASAIA LAB y creador de INTELIGENCIA LIBRE.

*Certificado en Pasaia, a 5 de junio de 2026.*

**Firma:** DeepSeek (asesor IA)
**Responsable:** José Agustín Fontán Varela

 

 

 

 

 

 

 

 

 

 

 

# 🎨 Prompt para Gemini – Sección "Raspberry Pi OS" de PASAIA LAB y TALLER INTELIGENCIA LIBRE

```
Genera una imagen de cabecera o banner de alta resolución (4K) en formato horizontal (16:9) que represente la sección "Raspberry Pi OS" del blog o web de PASAIA LAB y TALLER INTELIGENCIA LIBRE. El estilo debe ser técnico pero acogedor, con una paleta de colores cálidos: rojo intenso (similar al logo de Raspberry Pi), gris plata y azul profundo (tono de la placa Raspberry Pi). El fondo debe ser un degradado suave de gris a azul oscuro, con toques de rojo en los bordes y elementos destacados.

La composición debe incluir:

- En el centro, una Raspberry Pi 5 con una pantalla táctil de 3.5″ conectada, mostrando en su pantalla el texto "RASPBERRY PI OS" en letras blancas y rojas.
- Sobre la placa, flotando ligeramente, el logotipo de PASAIA LAB (un dron estilizado o un escudo con engranajes) y el símbolo de INTELIGENCIA LIBRE (un nudo celta tecnológico o un lobo de perfil). Ambos logotipos en tonos rojos y blancos.
- Alrededor de la Raspberry Pi, pequeños iconos que representan las herramientas que se instalan: un chip de IA (para AI HAT+), un engranaje con el símbolo de Docker, un escudo (para ciberseguridad), una impresora 3D (para Creality K1 SE), y una pantalla de terminal con código Python. Cada icono en colores rojo, gris o azul.
- En la parte superior, un título grande: "PASAIA LAB · TALLER INTELIGENCIA LIBRE" con tipografía moderna y robusta, en blanco con sombra roja.
- En la parte inferior, un subtítulo: "Raspberry Pi OS · Configuración · Ciberseguridad · IA en el borde".

- El fondo puede tener una ligera textura de circuitos o placa base, muy tenue, para dar sensación tecnológica sin saturar.

Estilo: ilustración digital moderna, combinación de render realista (para la Raspberry Pi) y elementos gráficos planos (para los iconos y textos). Iluminación suave. Formato horizontal 16:9, apto para cabecera de blog o canal de YouTube.

**USO PREVISTO:** Cabecera de sección en el blog de PASAIA LAB, imagen de portada para tutoriales sobre Raspberry Pi OS y proyectos de inteligencia libre.
```

PROYECTO DE CAMARA INTELIGENTE - by PASAIA LAB: # **Guía Completa: Instalación Raspberry Pi OS con SSD, Cámara HQ y Pantalla Táctil 3.5"**

 # **Guía Completa: Instalación Raspberry Pi OS con SSD, Cámara HQ y Pantalla Táctil 3.5"**

ESTE LABORATORIO OFRECE MUCHO GENEROSAMENTE ;    

 

 

RETORNO DE ESFUERZO: WALLET BITCOIN BTC 

 

 

## **1. PREPARACIÓN INICIAL**

### **Descargar Raspberry Pi OS (Bookworm)**
```bash
# Opción A: Usar Raspberry Pi Imager (RECOMENDADO)
# Descargar desde: https://www.raspberrypi.com/software/

# Opción B: Descarga manual
wget https://downloads.raspberrypi.com/raspios_arm64/images/raspios_arm64-2023-12-11/2023-12-11-raspios-bookworm-arm64.img.xz
```

## **2. INSTALACIÓN EN SSD M.2 SATA**

### **Usar Raspberry Pi Imager (Método más fácil):**
1. **Insertar SSD** en adaptador USB a M.2
2. **Ejecutar Raspberry Pi Imager**
3. **Seleccionar:** Raspberry Pi OS (64-bit) Bookworm
4. **Seleccionar almacenamiento:** Tu SSD de 512GB
5. **ANTES DE ESCRIBIR:**
   - Presionar **Ctrl+Shift+X** para opciones avanzadas
   - Configurar:
     ```
     Hostname: raspberrypi (o el que prefieras)
     Enable SSH: ✓ Con autenticación por contraseña
     Username: pi (o el que prefieras)
     Password: [tu contraseña]
     Configure wireless LAN: ✓ (si usas WiFi)
     Set locale settings: es_ES.UTF-8 UTF-8
     Timezone: Europe/Madrid
     ```
6. **Escribir** en el SSD

### **Instalación manual desde terminal Linux:**
```bash
# Identificar el disco SSD
sudo lsblk

# Desmontar particiones (ejemplo: /dev/sda)
sudo umount /dev/sda*

# Escribir la imagen (AJUSTAR /dev/sda según tu caso)
sudo dd if=2023-12-11-raspios-bookworm-arm64.img of=/dev/sda bs=4M status=progress

# Sincronizar
sudo sync
```

## **3. CONFIGURACIÓN INICIAL DEL RASPBERRY PI**

### **Primer arranque:**
1. Conectar SSD al Raspberry Pi
2. Encender y esperar a que bootee (2-3 minutos primera vez)
3. Acceder vía SSH o directamente con teclado/monitor

### **Actualización del sistema:**
```bash
# Actualizar lista de paquetes
sudo apt update && sudo apt upgrade -y

# Actualizar firmware
sudo rpi-update

# Reiniciar
sudo reboot
```

## **4. CONFIGURAR PANTALLA TÁCTIL RASPBERRY PI 3.5"**

### **Instalar drivers para pantalla táctil:**
```bash
# Clonar repositorio del driver
git clone https://github.com/goodtft/LCD-show.git

# Entrar en directorio
cd LCD-show/

# Instalar driver específico para 3.5"
sudo ./LCD35-show

# O si la pantalla está rotada:
sudo ./LCD35-show 180  # Rotar 180 grados
```

### **Configuración manual alternativa:**
```bash
# Editar config.txt
sudo nano /boot/firmware/config.txt

# Añadir al FINAL del archivo:
# Para pantalla 3.5" SPI
dtparam=spi=on
dtoverlay=waveshare35a:rotate=270
# rotate puede ser: 0, 90, 180, 270

# Si tienes problemas de toque:
sudo apt install xinput-calibrator
# Luego calibrar:
DISPLAY=:0 xinput_calibrator
```

### **Optimizar para pantalla pequeña:**
```bash
# Instalar herramientas de escalado
sudo apt install xserver-xorg-input-evdev xinput

# Configurar DPI para mejor legibilidad
echo "Xft.dpi: 120" >> ~/.Xresources
xrdb -merge ~/.Xresources
```

## **5. CONFIGURAR CÁMARA HIGH QUALITY CAMERA 2020**

### **Habilitar cámara en interfaz:**
```bash
# Método 1: Usar raspi-config
sudo raspi-config
# Ir a: Interface Options → Camera → Enable

# Método 2: Manualmente
sudo nano /boot/firmware/config.txt
# Añadir o descomentar:
start_x=1
gpu_mem=256  # Recomendado para HQ Camera
```

### **Instalar software para la cámara:**
```bash
# Instalar librerías para cámara
sudo apt install -y python3-picamera2 python3-opencv
sudo apt install -y libcamera-apps

# Para interfaz gráfica con cámara
sudo apt install -y qv4l2 v4l-utils
```

### **Probar la cámara:**
```bash
# Probar con libcamera
libcamera-hello -t 0  # Vista previa continua

# Tomar foto
libcamera-jpeg -o foto.jpg

# Grabar video (10 segundos)
libcamera-vid -t 10000 -o video.h264

# Con Python (ejemplo básico)
python3 -c "from picamera2 import Picamera2; picam2 = Picamera2(); picam2.start(); picam2.capture_file('test.jpg')"
```

## **6. CONFIGURACIÓN AVANZADA DEL SSD**

### **Verificar que está booteando desde SSD:**
```bash
# Ver de dónde está booteando
sudo lsblk -o NAME,FSTYPE,LABEL,MOUNTPOINT,SIZE,MODEL

# Deberías ver algo como:
# sda    ext4   rootfs    /      476.9G  SSD_512GB
```

### **Optimizar SSD para Raspberry Pi:**
```bash
# Habilitar TRIM para SSD
sudo systemctl enable fstrim.timer
sudo systemctl start fstrim.timer

# Ajustar montaje para SSD
sudo nano /etc/fstab

# Añadir estas opciones a la partición root (ejemplo):
# UUID=xxxx-xxxx-xxxx / ext4 defaults,noatime,nodiratime,commit=600,errors=remount-ro 0 1

# Deshabilitar swap en SSD para mayor durabilidad
sudo dphys-swapfile swapoff
sudo dphys-swapfile uninstall
sudo systemctl disable dphys-swapfile
```

## **7. CONFIGURACIÓN TÁCTIL Y CALIBRACIÓN**

### **Calibrar pantalla táctil:**
```bash
# Instalar herramientas de calibración
sudo apt install xinput-calibrator

# Ejecutar calibración (debes estar en entorno gráfico)
export DISPLAY=:0
xinput_calibrator

# Los valores generados, añadirlos a:
sudo nano /etc/X11/xorg.conf.d/99-calibration.conf
# Contenido ejemplo:
Section "InputClass"
    Identifier      "calibration"
    MatchProduct    "generic ft5x06 (0)"
    Option  "Calibration"   "71 1990 117 1987"
    Option  "SwapAxes"      "0"
EndSection
```

### **Solucionar problemas táctiles:**
```bash
# Listar dispositivos de entrada
xinput list

# Probar eventos táctiles
evtest

# Reinstalar driver si hay problemas
sudo rm -rf /boot/overlays/waveshare35a.dtbo
sudo cp ~/LCD-show/waveshare35a.dtbo /boot/overlays/
```

## **8. INSTALACIÓN DE SOFTWARE ÚTIL**

### **Paquetes esenciales:**
```bash
# Para desarrollo y control
sudo apt install -y \
    python3-gpiozero \
    python3-pigpio \
    git \
    vim \
    htop \
    nmon \
    screen \
    tmux

# Para multimedia
sudo apt install -y \
    vlc \
    gimp \
    ffmpeg

# Para monitorización
sudo apt install -y \
    rpi-monitor \
    gpio-monitor
```

## **9. CONFIGURACIÓN FINAL Y OPTIMIZACIÓN**

### **Ajustes de rendimiento:**
```bash
# Overclocking seguro (Pi 4/5)
sudo nano /boot/firmware/config.txt
# Añadir:
over_voltage=2
arm_freq=1800  # Para Pi 4
# Para Pi 5 ajustar diferente

# Mejorar gestión térmica
sudo apt install -y psensor
sudo /opt/vc/bin/vcgencmd measure_temp
```

### **Automatizar inicio de aplicaciones:**
```bash
# Para iniciar aplicación al arranque
sudo nano /etc/xdg/autostart/miapp.desktop
# Contenido:
[Desktop Entry]
Type=Application
Name=Mi Aplicación
Exec=python3 /home/pi/miapp.py
```

## **10. COMANDOS DE DIAGNÓSTICO**

### **Verificar todo funciona:**
```bash
# Ver temperatura
vcgencmd measure_temp

# Ver voltajes
vcgencmd measure_volts

# Ver frecuencia CPU
vcgencmd measure_clock arm

# Ver estado cámara
libcamera-hello --list-cameras

# Ver resolución pantalla
xdpyinfo | grep dimensions

# Probar táctil
xinput test-xi2 --root
```

## **11. SCRIPT DE INSTALACIÓN COMPLETA**

Puedes crear un script de instalación automática:

```bash
#!/bin/bash
# guardar como setup_pi.sh

# Actualizar sistema
sudo apt update && sudo apt upgrade -y

# Instalar drivers pantalla
git clone https://github.com/goodtft/LCD-show.git
cd LCD-show
sudo ./LCD35-show
cd ..

# Instalar software cámara
sudo apt install -y libcamera-apps python3-picamera2

# Configuraciones finales
sudo raspi-config nonint do_camera 0
sudo raspi-config nonint do_ssh 0

echo "Instalación completada. Reiniciando..."
sudo reboot
```

## **PROBLEMAS COMUNES Y SOLUCIONES:**

1. **Pantalla no funciona:** 
   ```bash
   # Verificar conexiones y reinstalar driver
   sudo ./LCD-show/LCD35-show
   ```

2. **Cámara no detectada:**
   ```bash
   # Verificar cable y conexión
   vcgencmd get_camera
   # Debería mostrar: supported=1 detected=1
   ```

3. **SSD no arranca:**
   ```bash
   # Verificar boot order
   sudo raspi-config nonint do_boot_order 0
   ```

4. **Toque no calibrado:**
   ```bash
   # Recalibrar
   DISPLAY=:0 xinput_calibrator

   ```

¿Necesitas ayuda con algún paso específico o tienes algún problema durante la instalación?

CONTACTO: PASAIA LAB tormentaworkfactory@gmail.com 

 

 

 

 

# **WINSTON SMITH: ANTI-METADATA TOOL** 

 https://tormentaworkintelligencectiongroup.blogspot.com/2025/12/winston-smith-anti-metadata-tool.html

BRAINSTORMING - Tormenta de Ideas de PASAIA LAB © 2025 by José Agustín Fontán Varela is licensed under CC BY-NC-ND 4.0

BRAINSTORMING - Tormenta de Ideas de PASAIA LAB © 2025 by José Agustín Fontán Varela is licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International

Tormenta Work Free Intelligence + IA Free Intelligence Laboratory by José Agustín Fontán Varela is licensed under CC BY-NC-ND 4.0