Provoacă cu adevărat: 5 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

Lumea modernă cere oamenilor să iasă din fizic și să trăiască în digital.

Odată cu apariția lui Al și proliferarea tehnologiei, oamenii își pun prea multă încredere în mașină și cred că va fi întotdeauna corectă.

„Într-adevăr” este menit să scuture această încredere falsă prin crearea unui test fals al detectorului de minciuni. Oamenii vor crede cu ușurință că într-adevăr funcționează, dar atunci când sunt oferite răspunsuri false, le va zdruncina încrederea oarbă în tehnologie.

Pasul 1: Pasul 1: lipiți circuitul

Deoarece lucrările mele au o singură lumină, deci este foarte ușor de lipit. Problema principală este la început, am lipit două lumini, dar nu am acoperit imediat partea de expunere. Deci, când cele două fire se ating împreună. Se scurtează.

Pasul 2: Pasul 2: Scrieți codul

p.p1 {margin: 0,0px 0,0px 0,0px 0,0px; înălțimea liniei: 15,0 px; font: 12.0px Times; culoare: # 000000; culoare de fundal: #ffffff}

p.p2 {margin: 0,0px 0,0px 0,0px 0,0px; înălțimea liniei: 15,0 px; font: 12.0px Times; culoare: # 000000; culoare de fundal: #ffffff; min-height: 14.0px} span.s1 {font-kerning: none}

Pasul 2: scrieți codul

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

Acesta este un exemplu pentru modulele Bluefruit LE bazate pe nRF52

Luați unul astăzi în magazinul adafruit!

Adafruit investește timp și resurse oferind acest cod sursă deschisă, vă rugăm să sprijiniți Adafruit și hardware open-source prin achiziționare

produse de la Adafruit!

Licență MIT, verificați LICENȚA pentru mai multe informații

Tot textul de mai sus și ecranul de pornire de mai jos trebuie să fie incluse în

orice redistribuire

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

/ Această schiță este destinată utilizării cu controlul NeoPixel

// apare în aplicația mobilă Bluefruit LE Connect a Adafruit.

/

/ - Compilați și blocați această schiță pe nRF52 Feather

// - Deschideți aplicația Bluefruit LE Connect

// - Comutați la utilitarul NeoPixel

// - Faceți clic pe butonul „conectare” pentru a stabili o conexiune și

// trimiteți meta-datele despre aspectul pixelilor

// - Utilizați utilitarul NeoPixel pentru a actualiza pixelii de pe dispozitiv

/ * NOTĂ: Această schiță necesită cel puțin versiunea 1.1.0 a Adafruit_Neopixel !!! * /

#include

#include

#include

#define NEOPIXEL_VERSION_STRING "Neopixel v2.0"

#define PIN 16 / * Pin utilizat pentru a conduce NeoPixels * /

#define MAXCOMPONENTS 4

uint8_t * pixelBuffer = NULL;

uint8_t lățime = 0;

uint8_t înălțime = 0;

uint8_t pas;

uint8_t componentsValue;

bool este de 400Hz;

uint8_t components = 3; // doar 3 și 4 sunt valori valide

Adafruit_NeoPixel neopixel = Adafruit_NeoPixel ();

// Serviciul BLE

BLEDfu bledfu;

BLEDis bledis;

BLEUart bleuart;

configurare nulă ()

{

Serial.begin (115200);

În timp ce (! Serial) întârziere (10); // pentru nrf52840 cu usb nativ

Serial.println ("Adafruit Bluefruit Neopixel Test");

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

Serial.println ();

Serial.println („Vă rugăm să vă conectați utilizând aplicația Bluefruit Connect LE”);

// Configurați Neopixeli

neopixel.begin ();

// Init Bluefruit

Bluefruit.begin ();

Bluefruit.setTxPower (4); // Verificați bluefruit.h pentru valorile acceptate

Bluefruit.setName ("Bluefruit52");

Bluefruit. Periph.setConnectCallback (connect_callback);

// Pentru a fi coerent, OTA DFU trebuie adăugat mai întâi dacă există

bledfu.begin ();

// Configurați și porniți serviciul de informații despre dispozitiv

bledis.setManufacturer („Adafruit Industries”);

bledis.setModel ("Bluefruit Feather52");

bledis.begin ();

// Configurați și porniți serviciul BLE UART

bleuart.begin ();

// Configurați și începeți publicitatea

startAdv ();

}

void startAdv (nul)

{

// Pachet publicitar

Bluefruit. Advertising.addFlags (BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);

Bluefruit. Advertising.addTxPower ();

// Includeți uuid bleuart pe 128 de biți

Bluefruit. Advertising.addService (bleuart);

// Pachet de răspuns secundar la scanare (opțional)

// Deoarece nu există spațiu pentru „Nume” în pachetul de publicitate

Bluefruit. ScanResponse.addName ();

/ * Începeți publicitatea

* - Activați publicitatea automată dacă este deconectat

* - Interval: modul rapid = 20 ms, modul lent = 152,5 ms

* - Timpul expirat pentru modul rapid este de 30 de secunde

* - Start (timeout) cu timeout = 0 va face publicitate pentru totdeauna (până la conectare)

*

* Pentru intervalul de publicitate recomandat

*

*/

Bluefruit. Advertising.restartOnDisconnect (adevărat);

Bluefruit. Advertising.setInterval (32, 244); // în unitate de 0,625 ms

Bluefruit. Advertising.setFastTimeout (30); // numărul de secunde în modul rapid

Bluefruit. Advertising.start (0); // 0 = Nu opriți publicitatea după n secunde

}

void connect_callback (uint16_t conn_handle)

{

// Obțineți referința la conexiunea curentă

BLEConnection * connection = Bluefruit. Connection (conn_handle);

char central_name [32] = {0};

connection-> getPeerName (central_name, sizeof (central_name));

Serial.print („Conectat la”);

Serial.println (central_name);

Serial.println („Vă rugăm să selectați fila„ Neopixeli”, faceți clic pe„ Conectați-vă”și distrați-vă”);

}

bucla nulă ()

{

// Echo a primit date

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

{

int command = bleuart.read ();

comutare (comandă) {

cazul „V”: {// Obțineți versiunea

commandVersion ();

pauză;

}

carcasa „S”: {// Configurare dimensiuni, componente, pas …

commandSetup ();

pauză;

}

cazul „C”: {// Ștergeți cu culoare

commandClearColor ();

pauză;

}

cazul „B”: {// Setați Luminozitatea

commandSetBrightness ();

pauză;

}

majusculă „P”: {// Set Pixel

commandSetPixel ();

pauză;

}

cazul „I”: {// Primește o imagine nouă

commandImage ();

pauză;

}

}

}

}

void swapBuffers ()

{

uint8_t * base_addr = pixelBuffer;

int pixelIndex = 0;

pentru (int j = 0; j <înălțime; j ++)

{

for (int i = 0; i <width; i ++) {

if (componente == 3) {

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

}

altceva {

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

}

add_baza + = componente;

pixelIndex ++;

}

pixelIndex + = stride - lățime; // Mutați pixelIndex la rândul următor (luați în considerare pasul)

}

neopixel.show ();

}

void commandVersion () {

Serial.println (F ("Comandă: verificare versiune"));

sendResponse (NEOPIXEL_VERSION_STRING);

}

void commandSetup () {

Serial.println (F ("Comandă: Configurare"));

width = bleuart.read ();

înălțime = bleuart.read ();

stride = bleuart.read ();

componentsValue = bleuart.read ();

is400Hz = bleuart.read ();

neoPixelType pixelType;

pixelType = componentsValue + (is400Hz? NEO_KHZ400: NEO_KHZ800);

components = (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", lățime, înălțime);

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

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

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

if (pixelBuffer! = NULL) {

șterge pixelBuffer;

}

uint32_t mărime = lățime * înălțime;

pixelBuffer = new uint8_t [size * components];

neopixel.updateLength (dimensiune);

neopixel.updateType (pixelType);

neopixel.setPin (PIN);

// Terminat

sendResponse ("OK");

}

void commandSetBrightness () {

Serial.println (F ("Comandă: SetBrightness"));

// Citește valoarea

uint8_t luminozitate = bleuart.read ();

// Setați luminozitatea

neopixel.setBlightness (luminozitate);

// Actualizați pixeli

swapBuffers ();

// Terminat

sendResponse ("OK");

}

void commandClearColor () {

Serial.println (F ("Comandă: ClearColor"));

// Citește culoarea

uint8_t color [MAXCOMPONENTS];

pentru (int j = 0; j <componente;) {

if (bleuart.available ()) {

color [j] = bleuart.read ();

j ++;

}

}

// Setați toate ledurile la culoare

int size = latime * inaltime;

uint8_t * base_addr = pixelBuffer;

for (int i = 0; i <size; i ++) {

pentru (int j = 0; j <componente; j ++) {

* base_addr = culoare [j];

bază_addr ++;

}

}

// Schimbați tampoanele

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

swapBuffers ();

if (componente == 3) {

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

}

altceva {

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

}

// Terminat

sendResponse ("OK");

}

void commandSetPixel () {

Serial.println (F ("Comandă: SetPixel"));

// Citiți poziția

uint8_t x = bleuart.read ();

uint8_t y = bleuart.read ();

// Citește culorile

uint32_t pixelOffset = y * lățime + x;

uint32_t pixelDataOffset = componente pixelOffset *;

uint8_t * base_addr = pixelBuffer + pixelDataOffset;

pentru (int j = 0; j <componente;) {

if (bleuart.available ()) {

* base_addr = bleuart.read ();

bază_addr ++;

j ++;

}

}

// Setați culorile

uint32_t neopixelIndex = y * stride + x;

uint8_t * pixelBufferPointer = pixelBuffer + pixelDataOffset;

uint32_t culoare;

if (componente == 3) {

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

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

}

altceva {

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, culoare);

neopixel.show ();

// Terminat

sendResponse ("OK");

}

void commandImage () {

Serial.printf ("Comandă: Imagine% dx% d,% d,% d / n", lățime, înălțime, componente, pas);

// Primiți un tampon de pixeli nou

int size = latime * inaltime;

uint8_t * base_addr = pixelBuffer;

for (int i = 0; i <size; i ++) {

pentru (int j = 0; j <componente;) {

if (bleuart.available ()) {

* base_addr = bleuart.read ();

bază_addr ++;

j ++;

}

}

/*

if (componente == 3) {

uint32_t index = i * componente;

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

}

*/

}

// Schimbați tampoanele

Serial.println (F ("Imagine primită"));

swapBuffers ();

// Terminat

sendResponse ("OK");

}

void sendResponse (char const * response) {

Serial.printf ("Trimite răspuns:% s / n", răspuns);

bleuart.write (răspuns, strlen (răspuns) * sizeof (char));

}

Pasul 3: Pasul 3: Cumpărarea abajurului

Pasul 4: Pasul 4: Trageți totul împreună