Naprawdę wyzwanie: 5 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:29

Współczesny świat wymaga od ludzi wyjścia poza fizyczność i życia w cyfrowym.

Wraz z pojawieniem się Al i rozprzestrzenianiem się technologii ludzie zbytnio ufają maszynie i wierzą, że zawsze się sprawdza.

„Really” ma na celu wstrząsnąć tym fałszywym zaufaniem poprzez stworzenie fałszywego testu wykrywacza kłamstw. Ludzie z łatwością uwierzą, że Naprawdę działa, ale gdy zostaną udzielone fałszywe odpowiedzi, zachwieje to ich ślepe zaufanie do technologii.

Krok 1: Krok 1: Przylutuj obwód

Ponieważ moja praca ma tylko jedną lampkę, więc bardzo łatwo się lutuje. Główny problem jest na początku, lutuję dwa światła, ale nie zakryłem części naświetlania od razu. Więc kiedy dwa przewody stykają się ze sobą. To się kończy.

Krok 2: Krok 2: Napisz kod

p.p1 {marża: 0,0px 0,0px 0,0px 0,0px; wysokość linii: 15,0px; czcionka: 12,0px razy; kolor: #000000; kolor tła: #ffffff}

p.p2 {marża: 0,0px 0,0px 0,0px 0,0px; wysokość linii: 15,0px; czcionka: 12,0px razy; kolor: #000000; kolor tła: #ffffff; min-height: 14.0px} span.s1 {font-kerning: none}

Krok 2: Napisz kod

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

To jest przykład dla naszych modułów Bluefruit LE opartych na nRF52

Kup już dziś w sklepie adafruit!

Adafruit inwestuje czas i zasoby dostarczając ten kod open source, wesprzyj Adafruit i sprzęt open-source poprzez zakup

produkty od Adafruit!

Licencja MIT, sprawdź LICENCJA, aby uzyskać więcej informacji

Cały tekst powyżej i ekran powitalny poniżej muszą być zawarte w

jakakolwiek redystrybucja

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

/ Ten szkic jest przeznaczony do użytku ze sterownikiem NeoPixel

// wynurzyć się w aplikacji mobilnej Bluefruit LE Connect firmy Adafruit.

/

/ - Skompiluj i sflashuj ten szkic do pióra nRF52

// - Otwórz aplikację Bluefruit LE Connect

// - Przełącz się na narzędzie NeoPixel

// - Kliknij przycisk „Połącz”, aby nawiązać połączenie i

// wyślij metadane dotyczące układu pikseli

// - Użyj narzędzia NeoPixel, aby zaktualizować piksele na urządzeniu

/* UWAGA: Ten szkic wymagał co najmniej wersji 1.1.0 Adafruit_Neopixel !!! */

#włączać

#włączać

#włączać

#define NEOPIXEL_VERSION_STRING "Neopixel v2.0"

#define PIN 16 /* PIN używany do sterowania NeoPixels */

#define MAXKOMPONENTÓW 4

uint8_t *bufor pikseli = NULL;

szerokość uint8_t = 0;

wysokość uint8_t = 0;

uint8_t krok;

uint8_t componentsValue;

bool to 400 Hz;

składniki uint8_t = 3; // tylko 3 i 4 są prawidłowymi wartościami

Adafruit_NeoPixel neopiksel = Adafruit_NeoPixel();

// Usługa BLE

BLEDfu bledfu;

BLED jest bledis;

BLEUart bleuart;

pusta konfiguracja()

{

Serial.początek(115200);

while (!Serial) delay(10); // dla nrf52840 z natywnym usb

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

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

Serial.println();

Serial.println("Połącz się za pomocą aplikacji Bluefruit Connect LE");

// Konfiguracja Neopikseli

neopiksel.początek();

// Rozpocznij Bluefruit

Bluefruit.begin();

Bluefruit.setTxPower(4); // Sprawdź bluefruit.h pod kątem obsługiwanych wartości

Bluefruit.setName("Bluefruit52");

Bluefruit. Periph.setConnectCallback(connect_callback);

// Aby zachować spójność OTA DFU należy najpierw dodać, jeśli istnieje

bledfu.początek();

// Skonfiguruj i uruchom usługę informacji o urządzeniu

bledis.setManufacturer("Adafruit Industries");

bledis.setModel("Niebieskoowocowe Pióro52");

bledis.początek();

// Skonfiguruj i uruchom usługę BLE UART

bleuart.początek();

// Skonfiguruj i rozpocznij reklamę

startAdv();

}

void startAdv(void)

{

// Pakiet reklamowy

Bluefruit. Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);

Bluefruit. Reklama.addTxPower();

// Dołącz 128-bitowy identyfikator uuid bleuart

Bluefruit. Reklama.addService(bleuart);

// Dodatkowy pakiet odpowiedzi na skanowanie (opcjonalnie)

// Ponieważ w pakiecie reklamowym nie ma miejsca na 'Nazwa'

Bluefruit. ScanResponse.addName();

/* Rozpocznij reklamę

* - Włącz automatyczne reklamy po odłączeniu

* - Interwał: tryb szybki = 20 ms, tryb wolny = 152,5 ms

* - Limit czasu dla trybu szybkiego wynosi 30 sekund

* - Start(timeout) z timeout = 0 będzie reklamować się na zawsze (aż do połączenia)

*

* Dla zalecanego interwału reklamowego

*

*/

Bluefruit. Advertising.restartOnDisconnect(prawda);

Bluefruit. Advertising.setInterval(32, 244); // w jednostce 0,625 ms

Bluefruit. Reklama.setFastTimeout(30); // liczba sekund w trybie szybkim

Bluefruit. Reklama.start(0); // 0 = Nie przestawaj reklamować po n sekundach

}

void connect_callback(uint16_t conn_handle)

{

// Uzyskaj odniesienie do bieżącego połączenia

Połączenie BLEConnection* = Bluefruit. Connection(conn_handle);

char nazwa_centralna[32] = { 0 };

połączenie->getPeerName(nazwa_centralna, sizeof(nazwa_centralna));

Serial.print("Połączony z");

Serial.println(nazwa_centralna);

Serial.println("Wybierz zakładkę 'Neopiksele', kliknij 'Połącz' i baw się dobrze");

}

pusta pętla()

{

// Echo odebrał dane

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

{

int polecenie = bleuart.read();

przełącznik (polecenie) {

przypadek 'V': { // Pobierz wersję

wersja polecenia();

przerwa;

}

case „S”: { // Ustaw wymiary, komponenty, krok…

polecenieSetup();

przerwa;

}

case 'C': { // Wyczyść kolorem

polecenieWyczyśćKolor();

przerwa;

}

przypadek 'B': { // Ustaw jasność

polecenieZestawJasność();

przerwa;

}

przypadek 'P': { // Ustaw piksel

polecenieZestaw Pikseli();

przerwa;

}

case 'I': { // Odbierz nowy obraz

polecenieObraz();

przerwa;

}

}

}

}

void swapBuffers()

{

uint8_t *base_addr = pixelBuffer;

int pixelIndex = 0;

for (int j = 0; j < wysokość; j++)

{

for (int i = 0; i < szerokość; i++) {

jeśli (składniki == 3) {

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

}

w przeciwnym razie {

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

}

base_addr+=komponenty;

pikselIndeks++;

}

pixelIndex += krok - szerokość; // Przenieś pixelIndex do następnego wiersza (uwzględnij krok)

}

neopixel.show();

}

void polecenieWersja() {

Serial.println(F("Polecenie: Sprawdzenie wersji"));

sendResponse (NEOPIXEL_VERSION_STRING);

}

void ustawienia polecenia() {

Serial.println(F("Polecenie: Konfiguracja"));

szerokość = bleuart.odczyt();

wysokość = bleuart.odczyt();

krok = bleuart.czytaj();

ComponentValue = 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", szerokość, wysokość);

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

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

Serial.printf("\tkomponenty: %d\n", komponenty);

if (bufor pikseli != NULL) {

usuń pikselBufor;

}

uint32_t rozmiar = szerokość*wysokość;

pixelBuffer = nowy uint8_t[rozmiar*komponenty];

neopixel.updateLength(rozmiar);

neopixel.updateType(pixelType);

neopiksel.setPin(PIN);

// Gotowe

sendResponse("OK");

}

void polecenieUstawJasność() {

Serial.println(F("Polecenie: UstawJasność"));

// Odczytaj wartość

uint8_t jasność = bleuart.read();

// Ustaw jasność

neopixel.setJasność(jasność);

// Odśwież piksele

swapBufory();

// Gotowe

sendResponse("OK");

}

void polecenieWyczyśćKolor() {

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

// Odczytaj kolor

uint8_t kolor[MAXCOMPONENTS];

for (int j = 0; j < składniki;) {

if (bleuart.available()) {

kolor[j] = bleuart.odczyt();

j++;

}

}

// Ustaw wszystkie diody na kolor

int rozmiar = szerokość * wysokość;

uint8_t *base_addr = pixelBuffer;

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

for (int j = 0; j < składniki; j++) {

*adres_bazowy = kolor[j];

adres_podstawowy++;

}

}

// Zamień bufory

Serial.println(F("Ukończono ClearColor"));

swapBufory();

jeśli (składniki == 3) {

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

}

w przeciwnym razie {

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

}

// Gotowe

sendResponse("OK");

}

void polecenieZestawPixel() {

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

// Odczytaj pozycję

uint8_t x = bleuart.read();

uint8_t y = bleuart.read();

// Odczytaj kolory

uint32_t pixelOffset = y*szerokość+x;

uint32_t pixelDataOffset = pixelOffset*komponenty;

uint8_t *base_addr = pixelBuffer+pixelDataOffset;

for (int j = 0; j < składniki;) {

if (bleuart.available()) {

*base_addr = bleuart.read();

adres_podstawowy++;

j++;

}

}

// Ustaw kolory

uint32_t neopixelIndex = y*krok+x;

uint8_t *pixelBufferPointer = pixelBuffer + pixelDataOffset;

kolor uint32_t;

jeśli (składniki == 3) {

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

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

}

w przeciwnym razie {

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

neopixel.show();

// Gotowe

sendResponse("OK");

}

void polecenieObraz() {

Serial.printf("Polecenie: obraz %dx%d, %d, %d\n", szerokość, wysokość, komponenty, krok);

// Odbierz nowy bufor pikseli

int rozmiar = szerokość * wysokość;

uint8_t *base_addr = pixelBuffer;

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

for (int j = 0; j < składniki;) {

if (bleuart.available()) {

*base_addr = bleuart.read();

adres_podstawowy++;

j++;

}

}

/*

jeśli (składniki == 3) {

indeks uint32_t = i*komponenty;

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

}

*/

}

// Zamień bufory

Serial.println(F("Odebrano obraz"));

swapBufory();

// Gotowe

sendResponse("OK");

}

void sendResponse(char const *response) {

Serial.printf("Wyślij odpowiedź: %s\n", odpowiedź);

bleuart.write(odpowiedź, strlen(odpowiedź)*rozmiar(znak));

}

Krok 3: Krok 3: Kupowanie abażuru

Krok 4: Krok 4: Pociągnij wszystko razem