Innehållsförteckning:
2025 Författare: John Day | [email protected]. Senast ändrad: 2025-01-13 06:58
Den moderna världen kräver att människor kliver ur det fysiska och lever inom det digitala.
Med utseendet på Al och spridningen av teknik litar folk för mycket på maskinen och tror att den alltid är korrekt.
"Verkligen" är avsett att skaka detta falska förtroende genom att skapa ett falskt lögndetektorstest. Folk kommer lätt att tro att Really fungerar, men när falska svar ges kommer det att skaka deras blinda förtroende för teknik.
Steg 1: Steg 1: Löd kretsen
Eftersom mina verk bara har bara ett ljus, så det är mycket lätt att lödas. Huvudproblemet är i början, jag lödar två ljus, men jag täckte inte exponeringsdelen direkt. Så när de två ledningarna delas samman. Det blir kort.
Steg 2: Steg 2: Skriv koden
p.p1 {marginal: 0,0px 0,0px 0,0px 0,0px; radhöjd: 15,0 px; typsnitt: 12.0px Times; färg: #000000; bakgrundsfärg: #ffffff}
p.p2 {marginal: 0,0px 0,0px 0,0px 0,0px; radhöjd: 15,0 px; typsnitt: 12.0px Times; färg: #000000; bakgrundsfärg: #ffffff; min-height: 14.0px} span.s1 {font-kerning: none}
Steg 2: Skriv koden
/*********************************************************************
Detta är ett exempel på våra nRF52 -baserade Bluefruit LE -moduler
Hämta en idag i adafruitbutiken!
Adafruit investerar tid och resurser genom att tillhandahålla denna öppen källkod, stödja Adafruit och hårdvara med öppen källkod genom att köpa
produkter från Adafruit!
MIT -licens, kolla LICENS för mer information
All text ovan och stänkskärmen nedan måste inkluderas i
någon omfördelning
*********************************************************************
/ Denna skiss är avsedd att användas med NeoPixel -kontrollen
// yta i Adafruit's Bluefruit LE Connect mobilapplikation.
/
/ - Kompilera och flasha denna skiss till nRF52 -fjädern
// - Öppna Bluefruit LE Connect -appen
// - Byt till verktyget NeoPixel
// - Klicka på knappen 'anslut' för att upprätta en anslutning och
// skicka metadata om pixellayouten
// - Använd verktyget NeoPixel för att uppdatera pixlarna på din enhet
/* OBS: Denna skiss krävde minst version 1.1.0 av Adafruit_Neopixel !!! */
#omfatta
#omfatta
#omfatta
#define NEOPIXEL_VERSION_STRING "Neopixel v2.0"
#define PIN 16 / * Pin som används för att köra NeoPixels * /
#define MAXCOMPONENTS 4
uint8_t *pixelBuffer = NULL;
uint8_t bredd = 0;
uint8_t höjd = 0;
uint8_t steg;
uint8_t componentsValue;
bool är 400Hz;
uint8_t komponenter = 3; // endast 3 och 4 är giltiga värden
Adafruit_NeoPixel neopixel = Adafruit_NeoPixel ();
// BLE -tjänst
BLEDfu bledfu;
BLEDis bledis;
BLEUart bleuart;
void setup ()
{
Serial.begin (115200);
medan (! Seriell) fördröjning (10); // för nrf52840 med native usb
Serial.println ("Adafruit Bluefruit Neopixel Test");
Serial.println ("--------------------------------");
Serial.println ();
Serial.println ("Anslut med Bluefruit Connect LE -programmet");
// Config Neopixels
neopixel.begin ();
// Init Bluefruit
Bluefruit.begin ();
Bluefruit.setTxPower (4); // Kontrollera bluefruit.h för värden som stöds
Bluefruit.setName ("Bluefruit52");
Bluefruit. Periph.setConnectCallback (connect_callback);
// För att vara konsekvent måste OTA DFU läggas till först om det finns
bledfu.begin ();
// Konfigurera och starta Device Information Service
bledis.setMan Manufacturer ("Adafruit Industries");
bledis.setModel ("Bluefruit Feather52");
bledis.begin ();
// Konfigurera och starta BLE UART -tjänsten
bleuart.begin ();
// Sätt upp och börja annonsera
startAdv ();
}
void startAdv (void)
{
// Reklampaket
Bluefruit. Advertising.addFlags (BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);
Bluefruit. Advertising.addTxPower ();
// Inkludera bleuart 128-bitars uuid
Bluefruit. Advertising.addService (bleuart);
// Sekundärt skanningsresponspaket (tillval)
// Eftersom det inte finns plats för 'Namn' i reklampaketet
Bluefruit. ScanResponse.addName ();
/* Börja annonsera
* - Aktivera automatisk annonsering om den är bortkopplad
* - Intervall: snabbt läge = 20 ms, långsamt läge = 152,5 ms
* - Timeout för snabbt läge är 30 sekunder
* - Start (timeout) med timeout = 0 kommer att annonsera för alltid (tills den är ansluten)
*
* För rekommenderat reklamintervall
*
*/
Bluefruit. Advertising.restartOnDisconnect (true);
Bluefruit. Advertising.setInterval (32, 244); // i enheten 0,625 ms
Bluefruit. Advertising.setFastTimeout (30); // antal sekunder i snabbt läge
Bluefruit. Advertising.start (0); // 0 = Sluta inte annonsera efter n sekunder
}
void connect_callback (uint16_t conn_handle)
{
// Få referensen till aktuell anslutning
BLEConnection* anslutning = Bluefruit. Connection (conn_handle);
char central_name [32] = {0};
anslutning-> getPeerName (central_namn, sizeof (central_namn));
Serial.print ("Ansluten till");
Serial.println (central_namn);
Serial.println ("Välj" Neopixels "-fliken, klicka på" Connect "och ha kul");
}
void loop ()
{
// Echo mottog data
if (Bluefruit.connected () && bleuart.notifyEnabled ())
{
int kommando = bleuart.read ();
switch (kommando) {
fall 'V': {// Hämta version
commandVersion ();
ha sönder;
}
case 'S': {// Inställningsmått, komponenter, steg …
commandSetup ();
ha sönder;
}
fall 'C': {// Klar med färg
commandClearColor ();
ha sönder;
}
fall 'B': {// Ställ in ljusstyrka
commandSetBrightness ();
ha sönder;
}
fall 'P': {// Set Pixel
commandSetPixel ();
ha sönder;
}
fall 'I': {// Få en ny bild
commandImage ();
ha sönder;
}
}
}
}
void swapBuffers ()
{
uint8_t *base_addr = pixelBuffer;
int pixelIndex = 0;
för (int j = 0; j <höjd; j ++)
{
för (int i = 0; i <bredd; i ++) {
if (komponenter == 3) {
neopixel.setPixelColor (pixelIndex, neopixel. Color (*base_addr, *(base_addr+1), *(base_addr+2)));
}
annat {
neopixel.setPixelColor (pixelIndex, neopixel. Color (*base_addr, *(base_addr+1), *(base_addr+2), *(base_addr+3)));
}
base_addr+= komponenter;
pixelIndex ++;
}
pixelIndex += steg - bredd; // Flytta pixelIndex till nästa rad (ta hänsyn till steget)
}
neopixel.show ();
}
void commandVersion () {
Serial.println (F ("Kommando: Versionskontroll"));
sendResponse (NEOPIXEL_VERSION_STRING);
}
void commandSetup () {
Serial.println (F ("Kommando: Setup"));
bredd = bleuart.read ();
höjd = bleuart.read ();
stride = bleuart.read ();
componentsValue = bleuart.read ();
is400Hz = bleuart.read ();
neoPixelType pixelType;
pixelType = componentsValue + (is400Hz? NEO_KHZ400: NEO_KHZ800);
komponenter = (componentValue == NEO_RGB || komponenterValue == NEO_RBG || komponenterValue == NEO_GRB || componentsValue == NEO_GBR || komponenterValue == NEO_BRG || komponenterValue == NEO_BGR)? 3: 4;
Serial.printf ("\ tsize: %dx %d / n", bredd, höjd);
Serial.printf ("\ tstride: %d / n", steg);
Serial.printf ("\ tpixelType %d / n", pixelType);
Serial.printf ("\ tkomponenter: %d / n", komponenter);
if (pixelBuffer! = NULL) {
ta bort pixelBuffer;
}
uint32_t storlek = bredd*höjd;
pixelBuffer = ny uint8_t [storlek*komponenter];
neopixel.updateLength (storlek);
neopixel.updateType (pixelType);
neopixel.setPin (PIN);
// Gjort
sendResponse ("OK");
}
void commandSetBrightness () {
Serial.println (F ("Command: SetBrightness"));
// Läs värde
uint8_t ljusstyrka = bleuart.read ();
// Ställ in ljusstyrka
neopixel.setBrightness (ljusstyrka);
// Uppdatera pixlar
swapBuffers ();
// Gjort
sendResponse ("OK");
}
void commandClearColor () {
Serial.println (F ("Kommando: ClearColor"));
// Läs färg
uint8_t färg [MAXCOMPONENTS];
för (int j = 0; j <komponenter;) {
if (bleuart.available ()) {
färg [j] = bleuart.read ();
j ++;
}
}
// Ställ in alla lysdioder till färg
int storlek = bredd * höjd;
uint8_t *base_addr = pixelBuffer;
för (int i = 0; i <size; i ++) {
för (int j = 0; j <komponenter; j ++) {
*base_addr = färg [j];
base_addr ++;
}
}
// Byt buffert
Serial.println (F ("ClearColor slutförd"));
swapBuffers ();
if (komponenter == 3) {
Serial.printf ("\ tclear (%d, %d, %d) n", färg [0], färg [1], färg [2]);
}
annat {
Serial.printf ("\ tclear (%d, %d, %d, %d) n", färg [0], färg [1], färg [2], färg [3]);
}
// Gjort
sendResponse ("OK");
}
void commandSetPixel () {
Serial.println (F ("Command: SetPixel"));
// Läs position
uint8_t x = bleuart.read ();
uint8_t y = bleuart.read ();
// Läs färger
uint32_t pixelOffset = y*bredd+x;
uint32_t pixelDataOffset = pixelOffset*komponenter;
uint8_t *base_addr = pixelBuffer+pixelDataOffset;
för (int j = 0; j <komponenter;) {
if (bleuart.available ()) {
*base_addr = bleuart.read ();
base_addr ++;
j ++;
}
}
// Ställ in färger
uint32_t neopixelIndex = y*steg+x;
uint8_t *pixelBufferPointer = pixelBuffer + pixelDataOffset;
uint32_t färg;
if (komponenter == 3) {
color = neopixel. Color (*pixelBufferPointer, *(pixelBufferPointer+1), *(pixelBufferPointer+2));
Serial.printf ("\ tcolor (%d, %d, %d) n", *pixelBufferPointer, *(pixelBufferPointer+1), *(pixelBufferPointer+2));
}
annat {
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, färg);
neopixel.show ();
// Gjort
sendResponse ("OK");
}
void commandImage () {
Serial.printf ("Kommando: Bild %dx %d, %d, %d / n", bredd, höjd, komponenter, steg);
// Ta emot ny pixelbuffert
int storlek = bredd * höjd;
uint8_t *base_addr = pixelBuffer;
för (int i = 0; i <size; i ++) {
för (int j = 0; j <komponenter;) {
if (bleuart.available ()) {
*base_addr = bleuart.read ();
base_addr ++;
j ++;
}
}
/*
if (komponenter == 3) {
uint32_t index = i*komponenter;
Serial.printf ("\ tp %d (%d, %d, %d) n", i, pixelBuffer [index], pixelBuffer [index+1], pixelBuffer [index+2]);
}
*/
}
// Byt buffert
Serial.println (F ("Bild mottagen"));
swapBuffers ();
// Gjort
sendResponse ("OK");
}
void sendResponse (char const *response) {
Serial.printf ("Skicka svar: %s / n", svar);
bleuart.write (svar, strlen (svar)*sizeof (char));
}
Steg 3: Steg 3: Köp lampskärm
