Davvero una sfida: 5 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Il mondo moderno richiede agli umani di uscire dal fisico e vivere nel digitale.

Con la comparsa di Al e la proliferazione della tecnologia, le persone ripongono troppa fiducia nella macchina e credono che sia sempre corretta.

"Really" ha lo scopo di scuotere questa falsa fiducia attraverso la creazione di un falso test della macchina della verità. Le persone crederanno facilmente che Really stia funzionando, ma quando vengono fornite risposte false, la loro fiducia cieca nella tecnologia verrà scossa.

Passaggio 1: Passaggio 1: saldare il circuito

Perché i miei lavori hanno solo una luce, quindi è molto facile da saldare. Il problema principale è all'inizio, ho saldato due luci, ma non ho coperto immediatamente la parte dell'esposizione. Quindi quando i due fili si separano si toccano. È in cortocircuito.

Passaggio 2: Passaggio 2: Scrivi il codice

p.p1 {margine: 0,0 px 0,0 px 0,0 px 0,0 px; altezza della linea: 15.0px; carattere: 12.0px volte; colore: #000000; colore di sfondo: #ffffff}

p.p2 {margine: 0,0 px 0,0 px 0,0 px 0,0 px; altezza della linea: 15.0px; carattere: 12.0px volte; colore: #000000; colore di sfondo: #ffffff; altezza minima: 14.0px} span.s1 {font-kerning: nessuno}

Passaggio 2: scrivi il codice

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

Questo è un esempio per i nostri moduli Bluefruit LE basati su nRF52

Prendine uno oggi nel negozio di adafruit!

Adafruit investe tempo e risorse fornendo questo codice open source, si prega di supportare Adafruit e l'hardware open source acquistando

prodotti da Adafruit!

Licenza MIT, controlla LICENZA per maggiori informazioni

Tutto il testo sopra e la schermata iniziale sotto devono essere inclusi in

qualsiasi ridistribuzione

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

/ Questo disegno deve essere utilizzato con il controllo NeoPixel

// superficie nell'applicazione mobile Bluefruit LE Connect di Adafruit.

/

/ - Compila e flasha questo schizzo sul nRF52 Feather

// - Apri l'app Bluefruit LE Connect

// - Passa all'utility NeoPixel

// - Fare clic sul pulsante "Connetti" per stabilire una connessione e

// invia i meta-dati sul layout dei pixel

// - Usa l'utility NeoPixel per aggiornare i pixel sul tuo dispositivo

/* NOTA: questo sketch richiedeva almeno la versione 1.1.0 di Adafruit_Neopixel!!! */

#includere

#includere

#includere

#define NEOPIXEL_VERSION_STRING "Neopixel v2.0"

#define PIN 16 /* Pin utilizzato per pilotare i NeoPixel */

#define MAXCOMPONENTS 4

uint8_t *pixelBuffer = NULL;

uint8_t larghezza = 0;

uint8_t altezza = 0;

uint8_t passo;

uint8_t componentValue;

bool is400Hz;

uint8_t componenti = 3; // solo 3 e 4 sono valori validi

Adafruit_NeoPixel neopixel = Adafruit_NeoPixel();

// Servizio BLE

BLEDfu bledfu;

BLEDis bledis;

BLEUart bleuart;

configurazione nulla()

{

Serial.begin(115200);

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

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

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

Serial.println();

Serial.println("Connettiti utilizzando l'applicazione Bluefruit Connect LE");

// Configura Neopixel

neopixel.begin();

// Init Bluefruit

Bluefruit.begin();

Bluefruit.setTxPower(4); // Controlla bluefruit.h per i valori supportati

Bluefruit.setName("Bluefruit52");

Bluefruit. Periph.setConnectCallback(connect_callback);

// Per essere coerenti OTA DFU dovrebbe essere aggiunto prima se esiste

bledfu.begin();

// Configura e avvia il servizio di informazioni sul dispositivo

bledis.setManufacturer("Adafruit Industries");

bledis.setModel("Bluefruit Feather52");

bledis.begin();

// Configura e avvia il servizio BLE UART

bleuart.begin();

// Imposta e inizia a fare pubblicità

startAdv();

}

void startAdv(void)

{

// Pacchetto pubblicitario

Bluefruit. Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);

Bluefruit. Advertising.addTxPower();

// Include bleuart 128 bit uuid

Bluefruit. Advertising.addService(bleuart);

// Pacchetto di risposta alla scansione secondaria (opzionale)

// Poiché non c'è spazio per 'Nome' nel pacchetto pubblicitario

Bluefruit. ScanResponse.addName();

/* Inizia a fare pubblicità

* - Abilita la pubblicità automatica se disconnesso

* - Intervallo: modalità veloce = 20 ms, modalità lenta = 152,5 ms

* - Il timeout per la modalità veloce è di 30 secondi

* - Start(timeout) con timeout = 0 pubblicizzerà per sempre (fino alla connessione)

*

* Per l'intervallo pubblicitario consigliato

*

*/

Bluefruit. Advertising.restartOnDisconnect(true);

Bluefruit. Advertising.setInterval(32, 244); // in unità di 0,625 ms

Bluefruit. Advertising.setFastTimeout(30); // numero di secondi in modalità veloce

Bluefruit. Advertising.start(0); // 0 = Non interrompere la pubblicità dopo n secondi

}

void connect_callback(uint16_t conn_handle)

{

// Ottieni il riferimento alla connessione corrente

BLEConnection* connection = Bluefruit. Connection(conn_handle);

char nome_centrale[32] = { 0 };

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

Serial.print("Connesso a");

Serial.println(central_name);

Serial.println("Seleziona la scheda 'Neopixel', fai clic su 'Connetti' e divertiti");

}

ciclo vuoto()

{

// Echo dati ricevuti

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

{

int comando = bleuart.read();

switch (comando) {

case 'V': { // Ottieni versione

comandoVersione();

rottura;

}

case 'S': { // Imposta dimensioni, componenti, passo…

comandoSetup();

rottura;

}

case 'C': { // Cancella con colore

commandClearColor();

rottura;

}

caso 'B': { // Imposta luminosità

commandSetBrightness();

rottura;

}

case 'P': { // Imposta pixel

commandSetPixel();

rottura;

}

case 'I': { // Ricevi nuova immagine

commandImage();

rottura;

}

}

}

}

void swapBuffers()

{

uint8_t *base_addr = pixelBuffer;

int pixelIndex = 0;

for (int j = 0; j < altezza; j++)

{

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

if (componenti == 3) {

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

}

altro {

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

}

base_addr+=componenti;

pixelIndex++;

}

pixelIndex += passo - larghezza; // Sposta pixelIndex alla riga successiva (prendi in considerazione il passo)

}

neopixel.show();

}

void commandVersion() {

Serial.println(F("Comando: Controllo versione"));

sendResponse(NEOPIXEL_VERSION_STRING);

}

void commandSetup() {

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

larghezza = bleuart.read();

altezza = bleuart.read();

passo = bleuart.read();

componentValue = bleuart.read();

is400Hz = bleuart.read();

neoPixelType pixelType;

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

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

Serial.printf("\tsize: %dx%d\n", larghezza, altezza);

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

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

Serial.printf("\tcomponenti: %d\n", componenti);

if (pixelBuffer != NULL) {

elimina pixelBuffer;

}

uint32_t size = larghezza*altezza;

pixelBuffer = new uint8_t[dimensione*componenti];

neopixel.updateLength(dimensione);

neopixel.updateType(pixelType);

neopixel.setPin(PIN);

// Fatto

sendResponse("OK");

}

void commandSetBrightness() {

Serial.println(F("Comando: ImpostaLuminosità"));

// Leggi il valore

uint8_t luminosità = bleuart.read();

// Imposta la luminosità

neopixel.setBrightness(luminosità);

// Aggiorna i pixel

swapBuffer();

// Fatto

sendResponse("OK");

}

void comandoClearColor() {

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

// Leggi il colore

uint8_t color[MAXCOMPONENTS];

for (int j = 0; j < componenti;) {

if (bleuart.disponibile()) {

color[j] = bleuart.read();

j++;

}

}

// Imposta tutti i led sul colore

int size = larghezza * altezza;

uint8_t *base_addr = pixelBuffer;

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

for (int j = 0; j < componenti; j++) {

*base_addr = colore[j];

base_addr++;

}

}

// Scambia i buffer

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

swapBuffer();

if (componenti == 3) {

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

}

altro {

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

}

// Fatto

sendResponse("OK");

}

void commandSetPixel() {

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

// Leggi posizione

uint8_t x = bleuart.read();

uint8_t y = bleuart.read();

// Leggi i colori

uint32_t pixelOffset = y*larghezza+x;

uint32_t pixelDataOffset = pixelOffset*componenti;

uint8_t *base_addr = pixelBuffer+pixelDataOffset;

for (int j = 0; j < componenti;) {

if (bleuart.disponibile()) {

*base_addr = bleuart.read();

base_addr++;

j++;

}

}

// Imposta i colori

uint32_t neopixelIndex = y*stride+x;

uint8_t *pixelBufferPointer = pixelBuffer + pixelDataOffset;

uint32_t colore;

if (componenti == 3) {

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

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

}

altro {

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();

// Fatto

sendResponse("OK");

}

void commandImage() {

Serial.printf("Comando: Immagine %dx%d, %d, %d\n", larghezza, altezza, componenti, passo);

// Ricevi un nuovo buffer di pixel

int dimensione = larghezza * altezza;

uint8_t *base_addr = pixelBuffer;

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

for (int j = 0; j < componenti;) {

if (bleuart.disponibile()) {

*base_addr = bleuart.read();

base_addr++;

j++;

}

}

/*

if (componenti == 3) {

uint32_t indice = i*componenti;

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

}

*/

}

// Scambia i buffer

Serial.println(F("Immagine ricevuta"));

swapBuffer();

// Fatto

sendResponse("OK");

}

void sendResponse(char const *response) {

Serial.printf("Invia risposta: %s\n", risposta);

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

}

Passaggio 3: Passaggio 3: acquisto del paralume

Passaggio 4: Passaggio 4: metti tutto insieme