prompter: Dame el código para un ESP-32 que use la librería NimBLE para crear un servidor bluetooth que reciba un texto y lo imprima en consola.

assistant: Aquí hay un ejemplo de código en C++ que utiliza la librería NimBLE para crear un servidor Bluetooth en un ESP-32:

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>

BLEServer *pServer = NULL;
BLEService *pService = NULL;
BLECharacteristic *pCharacteristic = NULL;

class MyCallbacks: public BLECharacteristicCallbacks {
  void onWrite(BLECharacteristic *pCharacteristic) {
    std::string rxValue = pCharacteristic->getValue();

    if (rxValue.length() > 0) {
      Serial.println("Received value: ");
      for (int i = 0; i < rxValue.length(); i++) {
        Serial.print(rxValue[i]);
      }
      Serial.println();
    }
  }
};

void setup() {
  Serial.begin(115200);
  Serial.println("Starting BLE work!");

  BLEDevice::init("ESP32 Server");
  pServer = BLEDevice::createServer();
  pService = pServer->createService(SERVICE_UUID);
  pCharacteristic = pService->createCharacteristic(
    CHARACTERISTIC_UUID_RX,
    BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_WRITE
  );

  pCharacteristic->setCallbacks(new MyCallbacks());
  pService->start();

  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
  pAdvertising->addServiceUUID(SERVICE_UUID);
  pAdvertising->setScanResponse(false);
  pAdvertising->setMinPreferred(0x06);
  pAdvertising->setMaxPreferred(0x12);
  BLEDevice::startAdvertising();
  Serial.println("Characteristic defined! Now you can read it in your phone!");
}

void loop() {
  BLEDevice::poll();
}

En este ejemplo, se crea un servidor Bluetooth y un servicio con una característica que permite la escritura. La clase MyCallbacks implementa el manejador de eventos onWrite para imprimir en la consola cualquier texto recibido. Finalmente, el servidor se inicia y se comienza a escuchar en busca de dispositivos que quieran conectarse.

assistant: Aquí está un ejemplo de código en C++ para un ESP-32 que utiliza la librería NimBLE para crear un servidor Bluetooth que reciba un texto y lo imprima en la consola:

#include <esp_log.h>
#include <nimble/nimble_port.h>
#include <nimble/nimble_port_freertos.h>
#include <host/ble_hs.h>
#include <host/util/util.h>

static void ble_app_on_sync(void) {
    ESP_LOGI("Nimble", "Bluetooth initialized");
}

static int ble_app_gap_event(struct ble_gap_event *event, void *arg) {
    switch (event->type) {
        case BLE_GAP_EVENT_CONNECT:
            ESP_LOGI("Nimble", "Device connected");
            break;

        case BLE_GAP_EVENT_DISCONNECT:
            ESP_LOGI("Nimble", "Device disconnected");
            break;

        case BLE_GAP_EVENT_ADV_COMPLETE:
            ESP_LOGI("Nimble", "Advertising complete");
            break;

        case BLE_GAP_EVENT_SUBSCRIBE:
            ESP_LOGI("Nimble", "Subscription established");
            break;

        case BLE_GAP_EVENT_UNSUBSCRIBE:
            ESP_LOGI("Nimble", "Subscription removed");
            break;

        case BLE_GAP_EVENT_CONN_UPDATE:
            ESP_LOGI("Nimble", "Connection parameters updated");
            break;
    }

    return 0;
}

extern "C" void app_main(void) {
    nimble_port_init();
    nimble_port_run();

    ble_hs_cfg.sync_cb = ble_app_on_sync;
    ble_hs_cfg.gap_event_cb = ble_app_gap_event;

    ble_hs_id_infer_auto(0, 0);

    while (1) {
        nimble_port_poll();
    }
}

assistant: Aquí te proporciono un ejemplo de código en C++ para el ESP-32 utilizando la librería NimBLE para crear un servidor Bluetooth que reciba un texto y lo imprima en la consola: