Realmente desafío: 5 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:41

El mundo moderno requiere que los humanos salgan de lo físico y vivan dentro de lo digital.

Con la aparición de Al y la proliferación de la tecnología, la gente confía demasiado en la máquina y cree que siempre es correcta.

"Really" tiene la intención de sacudir esta falsa confianza mediante la creación de una prueba de detector de mentiras falso. La gente creerá fácilmente que Really está funcionando, pero cuando se brindan respuestas falsas, se debilitará su confianza ciega en la tecnología.

Paso 1: Paso 1: Suelde el circuito

Porque mi trabajo solo tiene una luz, por lo que es muy fácil de soldar. El principal problema es al principio, soldo dos luces, pero no cubrí la parte de exposición de inmediato. Entonces, cuando la parte de los dos cables se toquen. Es un cortocircuito.

Paso 2: Paso 2: Escriba el código

p.p1 {margen: 0.0px 0.0px 0.0px 0.0px; altura de línea: 15.0px; fuente: 12.0px Times; color: # 000000; color de fondo: #ffffff}

p.p2 {margen: 0.0px 0.0px 0.0px 0.0px; altura de línea: 15.0px; fuente: 12.0px Times; color: # 000000; color de fondo: #ffffff; min-height: 14.0px} span.s1 {font-kerning: none}

Paso 2: escriba el código

/*********************************************************************

Este es un ejemplo de nuestros módulos Bluefruit LE basados en nRF52

¡Compra uno hoy en la tienda de adafruit!

Adafruit invierte tiempo y recursos en proporcionar este código fuente abierto, apoye Adafruit y el hardware de código abierto comprando

productos de Adafruit!

Licencia MIT, consulte LICENCIA para obtener más información

Todo el texto anterior y la pantalla de presentación a continuación deben incluirse en

cualquier redistribución

*********************************************************************

/ Este boceto está destinado a ser utilizado con el control NeoPixel.

// superficie en la aplicación móvil Bluefruit LE Connect de Adafruit.

/

/ - Compile y muestre este boceto en el nRF52 Feather

// - Abra la aplicación Bluefruit LE Connect

// - Cambiar a la utilidad NeoPixel

// - Haga clic en el botón 'conectar' para establecer una conexión y

// envía los metadatos sobre el diseño de píxeles

// - Use la utilidad NeoPixel para actualizar los píxeles en su dispositivo

/ * NOTA: ¡¡¡Este boceto requiere al menos la versión 1.1.0 de Adafruit_Neopixel !!! * /

#incluir

#incluir

#incluir

#define NEOPIXEL_VERSION_STRING "Neopixel v2.0"

#define PIN 16 / * Pin utilizado para controlar los NeoPixels * /

#define MAXCOMPONENTS 4

uint8_t * pixelBuffer = NULL;

uint8_t ancho = 0;

uint8_t altura = 0;

uint8_t stride;

uint8_t componentsValue;

bool es 400Hz;

uint8_t componentes = 3; // solo 3 y 4 son valores válidos

Adafruit_NeoPixel neopixel = Adafruit_NeoPixel ();

// Servicio BLE

BLEDfu bledfu;

BLEDis bledis;

BLEUart bleuart;

configuración vacía ()

{

Serial.begin (115200);

while (! Serial) delay (10); // para nrf52840 con usb nativo

Serial.println ("Prueba de Adafruit Bluefruit Neopixel");

Serial.println ("--------------------------------");

Serial.println ();

Serial.println ("Conéctese mediante la aplicación Bluefruit Connect LE");

// Configurar Neopixels

neopixel.begin ();

// Init Bluefruit

Bluefruit.begin ();

Bluefruit.setTxPower (4); // Compruebe bluefruit.h para conocer los valores admitidos

Bluefruit.setName ("Bluefruit52");

Bluefruit. Periph.setConnectCallback (connect_callback);

// Para ser consistente, OTA DFU debe agregarse primero si existe

bledfu.begin ();

// Configurar e iniciar el servicio de información del dispositivo

bledis.setManufacturer ("Industrias Adafruit");

bledis.setModel ("Bluefruit Feather52");

bledis.begin ();

// Configurar e iniciar el servicio BLE UART

bleuart.begin ();

// Configurar y empezar a anunciar

startAdv ();

}

void startAdv (vacío)

{

// Paquete publicitario

Bluefruit. Advertising.addFlags (BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);

Bluefruit. Advertising.addTxPower ();

// Incluir uuid bleuart de 128 bits

Bluefruit. Advertising.addService (bleuart);

// Paquete de respuesta de escaneo secundario (opcional)

// Dado que no hay espacio para 'Nombre' en el paquete de publicidad

Bluefruit. ScanResponse.addName ();

/ * Iniciar publicidad

* - Habilitar la publicidad automática si está desconectado

* - Intervalo: modo rápido = 20 ms, modo lento = 152,5 ms

* - El tiempo de espera para el modo rápido es de 30 segundos

* - Inicio (tiempo de espera) con tiempo de espera = 0 se anunciará para siempre (hasta que se conecte)

*

* Para intervalo publicitario recomendado

*

*/

Bluefruit. Advertising.restartOnDisconnect (verdadero);

Bluefruit. Advertising.setInterval (32, 244); // en unidad de 0,625 ms

Bluefruit. Advertising.setFastTimeout (30); // número de segundos en modo rápido

Bluefruit. Advertising.start (0); // 0 = No dejes de anunciar después de n segundos

}

void connect_callback (uint16_t conn_handle)

{

// Obtener la referencia a la conexión actual

BLEConnection * conexión = Bluefruit. Connection (conn_handle);

char central_name [32] = {0};

conexión-> getPeerName (central_name, sizeof (central_name));

Serial.print ("Conectado a");

Serial.println (nombre_central);

Serial.println ("Seleccione la pestaña 'Neopixels', haga clic en 'Conectar' y diviértase");

}

bucle vacío ()

{

// Eco de datos recibidos

si (Bluefruit.connected () && bleuart.notifyEnabled ())

{

int comando = bleuart.read ();

cambiar (comando) {

case 'V': {// Obtener versión

commandVersion ();

rotura;

}

case 'S': {// Configurar dimensiones, componentes, zancada …

commandSetup ();

rotura;

}

case 'C': {// Limpiar con color

commandClearColor ();

rotura;

}

case 'B': {// Establecer brillo

commandSetBrightness ();

rotura;

}

case 'P': {// Establecer píxel

commandSetPixel ();

rotura;

}

case 'I': {// Recibir nueva imagen

commandImage ();

rotura;

}

}

}

}

void swapBuffers ()

{

uint8_t * base_addr = pixelBuffer;

int pixelIndex = 0;

para (int j = 0; j <altura; j ++)

{

para (int i = 0; i <ancho; i ++) {

si (componentes == 3) {

neopixel.setPixelColor (pixelIndex, neopixel. Color (* base_addr, * (base_addr + 1), * (base_addr + 2)));

}

demás {

neopixel.setPixelColor (pixelIndex, neopixel. Color (* base_addr, * (base_addr + 1), * (base_addr + 2), * (base_addr + 3)));

}

base_addr + = componentes;

pixelIndex ++;

}

pixelIndex + = zancada - ancho; // Mover pixelIndex a la siguiente fila (tener en cuenta el paso)

}

neopixel.show ();

}

void commandVersion () {

Serial.println (F ("Comando: Verificación de versión"));

sendResponse (NEOPIXEL_VERSION_STRING);

}

void commandSetup () {

Serial.println (F ("Comando: Configuración"));

ancho = bleuart.read ();

altura = bleuart.read ();

zancada = bleuart.read ();

componentsValue = bleuart.read ();

is400Hz = bleuart.read ();

neoPixelType pixelType;

pixelType = componentsValue + (¿400Hz? NEO_KHZ400: NEO_KHZ800);

componentes = (componentsValue == NEO_RGB || componentsValue == NEO_RBG || componentsValue == NEO_GRB || componentsValue == NEO_GBR || componentsValue == NEO_BRG || componentsValue == NEO_BGR)? 3: 4;

Serial.printf ("\ tsize:% dx% d / n", ancho, alto);

Serial.printf ("\ tstride:% d / n", zancada);

Serial.printf ("\ tpixelType% d / n", pixelType);

Serial.printf ("\ tcomponents:% d / n", componentes);

if (pixelBuffer! = NULL) {

eliminar pixelBuffer;

}

uint32_t tamaño = ancho * alto;

pixelBuffer = new uint8_t [tamaño * componentes];

neopixel.updateLength (tamaño);

neopixel.updateType (pixelType);

neopixel.setPin (PIN);

// Hecho

sendResponse ("Aceptar");

}

void commandSetBrightness () {

Serial.println (F ("Command: SetBrightness"));

// Leer valor

uint8_t brillo = bleuart.read ();

// Establecer brillo

neopixel.setBrightness (brillo);

// Actualizar píxeles

swapBuffers ();

// Hecho

sendResponse ("Aceptar");

}

void commandClearColor () {

Serial.println (F ("Comando: ClearColor"));

// Leer color

uint8_t color [MAXCOMPONENTS];

para (int j = 0; j <componentes;) {

if (bleuart.available ()) {

color [j] = bleuart.read ();

j ++;

}

}

// Establecer todos los leds a color

int tamaño = ancho * alto;

uint8_t * base_addr = pixelBuffer;

para (int i = 0; i <tamaño; i ++) {

para (int j = 0; j <componentes; j ++) {

* base_addr = color [j];

base_addr ++;

}

}

// Intercambiar búferes

Serial.println (F ("ClearColor completado"));

swapBuffers ();

si (componentes == 3) {

Serial.printf ("\ tclear (% d,% d,% d) n", color [0], color [1], color [2]);

}

demás {

Serial.printf ("\ tclear (% d,% d,% d,% d) n", color [0], color [1], color [2], color [3]);

}

// Hecho

sendResponse ("Aceptar");

}

void commandSetPixel () {

Serial.println (F ("Comando: SetPixel"));

// Leer posición

uint8_t x = bleuart.read ();

uint8_t y = bleuart.read ();

// Leer colores

uint32_t pixelOffset = y * ancho + x;

uint32_t pixelDataOffset = pixelOffset * componentes;

uint8_t * base_addr = pixelBuffer + pixelDataOffset;

para (int j = 0; j <componentes;) {

if (bleuart.available ()) {

* base_addr = bleuart.read ();

base_addr ++;

j ++;

}

}

// Establecer colores

uint32_t neopixelIndex = y * zancada + x;

uint8_t * pixelBufferPointer = pixelBuffer + pixelDataOffset;

uint32_t color;

si (componentes == 3) {

color = neopixel. Color (* pixelBufferPointer, * (pixelBufferPointer + 1), * (pixelBufferPointer + 2));

Serial.printf ("\ tcolor (% d,% d,% d) n", * pixelBufferPointer, * (pixelBufferPointer + 1), * (pixelBufferPointer + 2));

}

demás {

color = neopixel. Color (* pixelBufferPointer, * (pixelBufferPointer + 1), * (pixelBufferPointer + 2), * (pixelBufferPointer + 3));

Serial.printf ("\ tcolor (% d,% d,% d,% d) n", * pixelBufferPointer, * (pixelBufferPointer + 1), * (pixelBufferPointer + 2), * (pixelBufferPointer + 3));

}

neopixel.setPixelColor (neopixelIndex, color);

neopixel.show ();

// Hecho

sendResponse ("Aceptar");

}

void commandImage () {

Serial.printf ("Comando: Imagen% dx% d,% d,% d / n", ancho, alto, componentes, paso);

// Recibe un nuevo búfer de píxeles

int tamaño = ancho * alto;

uint8_t * base_addr = pixelBuffer;

para (int i = 0; i <tamaño; i ++) {

para (int j = 0; j <componentes;) {

if (bleuart.available ()) {

* base_addr = bleuart.read ();

base_addr ++;

j ++;

}

}

/*

si (componentes == 3) {

uint32_t index = i * componentes;

Serial.printf ("\ tp% d (% d,% d,% d) n", i, pixelBuffer [índice], pixelBuffer [índice + 1], pixelBuffer [índice + 2]);

}

*/

}

// Intercambiar búferes

Serial.println (F ("Imagen recibida"));

swapBuffers ();

// Hecho

sendResponse ("Aceptar");

}

void sendResponse (char constante * respuesta) {

Serial.printf ("Enviar respuesta:% s / n", respuesta);

bleuart.write (respuesta, strlen (respuesta) * sizeof (char));

}

Paso 3: Paso 3: Compra de pantalla

Paso 4: Paso 4: júntelo todo