Tabla de contenido:
2025 Autor: John Day | [email protected]. Última modificación: 2025-01-13 06:57
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
