Haz que en lugar de mandar el "Hello, Riot"; se envie datos de temperatura y humedad de un sensor dht11.
```
#include <stdio.h>
#include <string.h>
#include "net/sock/udp.h"
#include "net/ipv6/addr.h"
#include "shell.h"
#include "thread.h"
#include "xtimer.h"
#include "net/gnrc/netif.h"
#include "net/netdev.h"  // Incluir la librería necesaria para manipular netdev

#define MAIN_QUEUE_SIZE (8)
static msg_t _main_msg_queue[MAIN_QUEUE_SIZE];

#define SERVER_ADDR "fe80::3230:f9ff:fe33:4cdd" // Dirección IPv6 del servidor
#define SERVER_PORT 8888
#define CLIENT_PORT 8889
#define BUFFER_SIZE 128
#define WIFI_CHANNEL 11  // Canal de WiFi configurado en 11

static char _udp_client_stack[THREAD_STACKSIZE_DEFAULT];
static char buffer[BUFFER_SIZE];

void *udp_client(void *arg) {
    (void)arg;
    msg_init_queue(_main_msg_queue, MAIN_QUEUE_SIZE);

    sock_udp_ep_t local = SOCK_IPV6_EP_ANY;
    local.port = CLIENT_PORT;

    sock_udp_ep_t remote;
    // Asegúrate de que ipv6_addr_t sea el tipo correcto
    ipv6_addr_t ipv6_addr;
    if (ipv6_addr_from_str(&ipv6_addr, SERVER_ADDR) == NULL) {
        printf("Error parsing server address\n");
        return NULL;
    }
    memcpy(&remote.addr.ipv6, &ipv6_addr, sizeof(ipv6_addr_t));
    remote.family = AF_INET6;
    remote.netif = 0; // Ajusta este valor según tu interfaz
    remote.port = SERVER_PORT;

    sock_udp_t sock;
    if (sock_udp_create(&sock, &local, NULL, 0) < 0) {
        printf("Error initializing socket\n");
        return NULL;
    }

    while (1) {
        snprintf(buffer, BUFFER_SIZE, "Hello, RIOT!");
        if (sock_udp_send(&sock, buffer, strlen(buffer), &remote) < 0) {
            printf("Error sending message\n");
        } else {
            printf("Message sent to [%s]:%u\n", SERVER_ADDR, SERVER_PORT);
        }

        xtimer_sleep(5); // Espera 5 segundos antes de enviar el siguiente mensaje
    }

    return NULL;
}

int main(void) {
    msg_init_queue(_main_msg_queue, MAIN_QUEUE_SIZE);

    // Configurar la interfaz WiFi para usar el canal 11 utilizando netdev
    gnrc_netif_t *netif = gnrc_netif_iter(NULL);
    if (netif != NULL) {
        netdev_t *dev = netif->dev;
        if (dev != NULL) {
            // Configurar el canal a través de la API netdev
            netopt_enable_t enable = NETOPT_ENABLE;
            int channel = WIFI_CHANNEL;  // Almacena el canal en una variable
            dev->driver->set(dev, NETOPT_CHANNEL, &channel, sizeof(channel));
            dev->driver->set(dev, NETOPT_STATE, &enable, sizeof(enable));
            printf("Configurado canal WiFi en: %d\n", WIFI_CHANNEL);
        } else {
            puts("Error: no se pudo acceder al dispositivo netdev.");
        }
    } else {
        puts("Error: no se encontró interfaz de red.");
    }

    // Inicia el cliente UDP
    printf("Starting UDP client\n");
    thread_create(_udp_client_stack, sizeof(_udp_client_stack),
                  THREAD_PRIORITY_MAIN - 1, THREAD_CREATE_STACKTEST,
                  udp_client, NULL, "UDP Client");

    // Inicia el shell
    static const shell_command_t shell_commands[] = {
        { NULL, NULL, NULL }
    };
    char line_buf[SHELL_DEFAULT_BUFSIZE];
    shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE);

    return 0;
}

```
```
# name of your application
APPLICATION = gnrc_networking

# If no BOARD is found in the environment, use this default:
BOARD ?= esp8266-esp-12x

# This has to be the absolute path to the RIOT base directory:
RIOTBASE ?= $(CURDIR)/../..

# Include packages that pull up and auto-init the link layer.
# NOTE: 6LoWPAN will be included if IEEE802.15.4 devices are present
USEMODULE += netdev_default
USEMODULE += auto_init_gnrc_netif
# Activate ICMPv6 error messages
USEMODULE += gnrc_icmpv6_error
# Specify the mandatory networking module for a IPv6 routing node
USEMODULE += gnrc_ipv6_router_default
# Add a routing protocol
USEMODULE += gnrc_rpl
USEMODULE += auto_init_gnrc_rpl
# Additional networking modules that can be dropped if not needed
USEMODULE += gnrc_icmpv6_echo
USEMODULE += shell_cmd_gnrc_udp
# Add also the shell, some shell commands
USEMODULE += shell
USEMODULE += shell_cmds_default
USEMODULE += ps
USEMODULE += netstats_l2
USEMODULE += netstats_ipv6
USEMODULE += netstats_rpl
PREFIX_CONF ?= dhcpv6
USEMODULE += gnrc_dhcpv6_client_6lbr

# Optionally include DNS support. This includes resolution of names at an
# upstream DNS server and the handling of RDNSS options in Router Advertisements
# to auto-configure that upstream DNS server.
# USEMODULE += sock_dns              # include DNS client
# USEMODULE += gnrc_ipv6_nib_dns     # include RDNSS option handling

# Comment this out to disable code in RIOT that does safety checking
# which is not needed in a production environment but helps in the
# development process:
DEVELHELP ?= 1

# Instead of simulating an Ethernet connection, we can also simulate
# an IEEE 802.15.4 radio using ZEP
USE_ZEP ?= 0

# set the ZEP port for native
ZEP_PORT_BASE ?= 17754
ifeq (1,$(USE_ZEP))
  USEMODULE += socket_zep
endif

# Uncomment the following 2 lines to specify static link lokal IPv6 address
# this might be useful for testing, in cases where you cannot or do not want to
# run a shell with ifconfig to get the real link lokal address.
#IPV6_STATIC_LLADDR ?= '"fe80::cafe:cafe:cafe:1"'
#CFLAGS += -DCONFIG_GNRC_IPV6_STATIC_LLADDR=$(IPV6_STATIC_LLADDR)

# Uncomment this to join RPL DODAGs even if DIOs do not contain
# DODAG Configuration Options (see the doc for more info)
# CFLAGS += -DCONFIG_GNRC_RPL_DODAG_CONF_OPTIONAL_ON_JOIN

# Change this to 0 show compiler invocation lines by default:
QUIET ?= 1

EXTERNAL_BOARD_DIRS += $(RIOTBASE)/tests/build_system/external_board_dirs/esp-ci-boards

include $(RIOTBASE)/Makefile.include

# Set a custom channel if needed
include $(RIOTMAKE)/default-radio-settings.inc.mk
```