वास्तव में चुनौती: 5 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:20

आधुनिक दुनिया में मनुष्य को भौतिक से बाहर निकलने और डिजिटल के भीतर रहने की आवश्यकता है।

अल की उपस्थिति और प्रौद्योगिकी के प्रसार के साथ लोग मशीन पर बहुत अधिक भरोसा करते हैं और मानते हैं कि यह हमेशा सही होता है।

"रियली" का उद्देश्य नकली लाई डिटेक्टर टेस्ट के निर्माण के माध्यम से इस झूठे भरोसे को हिला देना है। लोगों को आसानी से विश्वास हो जाएगा कि वास्तव में काम कर रहा है लेकिन जब झूठे उत्तर दिए जाएंगे तो यह तकनीक में उनके अंध विश्वास को हिला देगा।

चरण 1: चरण 1: सर्किट को मिलाएं

क्योंकि मेरे कार्यों में केवल एक ही प्रकाश है, इसलिए सोल्डर करना बहुत आसान है। मुख्य समस्या शुरुआत में है, मैं दो प्रकाश मिलाप करता हूं, लेकिन मैंने एक्सपोजर भाग को तुरंत कवर नहीं किया। तो जब दो तार भाग एक साथ स्पर्श करते हैं। यह शॉर्ट आउट।

चरण 2: चरण 2: कोड लिखें

p.p1 {मार्जिन: 0.0px 0.0px 0.0px 0.0px; लाइन-ऊंचाई: 15.0px; फ़ॉन्ट: 12.0px टाइम्स; रंग: #000000; पृष्ठभूमि-रंग: #ffffff}

p.p2 {मार्जिन: 0.0px 0.0px 0.0px 0.0px; लाइन-ऊंचाई: 15.0px; फ़ॉन्ट: 12.0px टाइम्स; रंग: #000000; पृष्ठभूमि-रंग: #ffffff; न्यूनतम-ऊंचाई: 14.0px} span.s1 {फ़ॉन्ट-कर्निंग: कोई नहीं}

चरण 2: कोड लिखें

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

यह हमारे nRF52 आधारित ब्लूफ्रूट LE मॉड्यूल के लिए एक उदाहरण है

एडफ्रूट की दुकान से आज ही एक खरीदें!

Adafruit इस ओपन सोर्स कोड को प्रदान करने में समय और संसाधनों का निवेश करता है, कृपया खरीद कर एडफ्रूट और ओपन-सोर्स हार्डवेयर का समर्थन करें

एडफ्रूट के उत्पाद!

एमआईटी लाइसेंस, अधिक जानकारी के लिए लाइसेंस की जांच करें

उपरोक्त सभी पाठ, और नीचे स्प्लैश स्क्रीन को शामिल किया जाना चाहिए

कोई पुनर्वितरण

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

/ इस स्केच का उद्देश्य NeoPixel नियंत्रण के साथ प्रयोग करना है

// एडफ्रूट के ब्लूफ्रूट ले कनेक्ट मोबाइल एप्लिकेशन में सतह।

/

/ - इस स्केच को nRF52 फेदर में संकलित और फ्लैश करें

// - ब्लूफ्रूट ले कनेक्ट ऐप खोलें

// - NeoPixel उपयोगिता पर स्विच करें

// - कनेक्शन स्थापित करने के लिए 'कनेक्ट' बटन पर क्लिक करें और

// पिक्सेल लेआउट के बारे में मेटा-डेटा भेजें

// - अपने डिवाइस पर पिक्सल को अपडेट करने के लिए NeoPixel उपयोगिता का उपयोग करें

/* नोट: इस स्केच के लिए Adafruit_Neopixel के कम से कम 1.1.0 संस्करण की आवश्यकता है !!! */

#शामिल

#शामिल

#शामिल

#define NEOPIXEL_VERSION_STRING "नियोपिक्सल v2.0"

#डिफाइन पिन 16 /* NeoPixels को चलाने के लिए इस्तेमाल किया जाने वाला पिन */

# MAXCOMPOENTS परिभाषित करें 4

uint8_t * पिक्सेलबफ़र = NULL;

uint8_t चौड़ाई = 0;

uint8_t ऊंचाई = 0;

uint8_t स्ट्राइड;

uint8_t घटक वैल्यू;

बूल 400 हर्ट्ज है;

uint8_t घटक = 3; // केवल 3 और 4 मान्य मान हैं

Adafruit_NeoPixel neopixel = Adafruit_NeoPixel ();

// बीएलई सेवा

BLEDfu ब्लेडफू;

ब्लीडिस ब्लीडिस;

ब्लूआर्ट ब्लूअर्ट;

व्यर्थ व्यवस्था()

{

सीरियल.बेगिन (115200);

जबकि (! सीरियल) देरी (10); // देशी यूएसबी के साथ nrf52840 के लिए

Serial.println ("एडफ्रूट ब्लूफ्रूट नियोपिक्सल टेस्ट");

सीरियल.प्रिंट्लन ("-------------------------------------");

सीरियल.प्रिंट्लन ();

Serial.println ("कृपया ब्लूफ्रूट कनेक्ट एलई एप्लिकेशन का उपयोग करके कनेक्ट करें");

// कॉन्फिग नियोपिक्सल

neopixel.begin ();

// इनिट ब्लूफ्रूट

ब्लूफ्रूट। शुरू ();

Bluefruit.setTxPower(4); // समर्थित मूल्यों के लिए bluefruit.h जांचें

Bluefruit.setName ("ब्लूफ्रूट 52");

Bluefruit. Periph.setConnectCallback (connect_callback);

// सुसंगत होने के लिए OTA DFU को पहले जोड़ा जाना चाहिए यदि यह मौजूद है

bledfu.begin ();

// कॉन्फ़िगर करें और डिवाइस सूचना सेवा शुरू करें

bledis.setManufacturer ("एडफ्रूट इंडस्ट्रीज");

bledis.setModel ("ब्लूफ्रूट फेदर 52");

bledis.begin ();

// कॉन्फ़िगर करें और BLE UART सेवा शुरू करें

bleuart.begin ();

// सेट अप करें और विज्ञापन शुरू करें

स्टार्टएड ();

}

शून्य startAdv (शून्य)

{

// विज्ञापन पैकेट

Bluefruit. Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);

Bluefruit. Advertising.addTxPower ();

// ब्ल्यूअर्ट 128-बिट यूयूआईडी शामिल करें

Bluefruit. Advertising.addService(bleuart);

// सेकेंडरी स्कैन रिस्पांस पैकेट (वैकल्पिक)

// चूंकि विज्ञापन पैकेट में 'नाम' के लिए कोई जगह नहीं है

Bluefruit. ScanResponse.addName ();

/* विज्ञापन शुरू करें

* - डिस्कनेक्ट होने पर ऑटो विज्ञापन सक्षम करें

* - अंतराल: तेज़ मोड = 20 ms, धीमा मोड = 152.5 ms

* - फास्ट मोड के लिए टाइमआउट 30 सेकंड है

* - टाइमआउट = 0 के साथ प्रारंभ (समयबाह्य) हमेशा के लिए विज्ञापन देगा (जब तक जुड़ा नहीं)

*

* अनुशंसित विज्ञापन अंतराल के लिए

*

*/

Bluefruit. Advertising.restartOnDisconnect(true);

Bluefruit. Advertising.setInterval(32, 244); // 0.625 एमएस. की इकाई में

Bluefruit. Advertising.setFastTimeout(30); // फास्ट मोड में सेकंड की संख्या

ब्लूफ्रूट।विज्ञापन।शुरू(0); // 0 = n सेकंड के बाद विज्ञापन बंद न करें

}

शून्य कनेक्ट_कॉलबैक (uint16_t conn_handle)

{

// वर्तमान कनेक्शन का संदर्भ प्राप्त करें

BLEConnection* कनेक्शन = Bluefruit. Connection(conn_handle);

चार सेंट्रल_नाम [32] = {0};

कनेक्शन-> getPeerName (केंद्रीय_नाम, आकार (केंद्रीय_नाम));

सीरियल.प्रिंट ("कनेक्टेड");

Serial.println(central_name);

Serial.println ("कृपया 'नियोपिक्सल' टैब चुनें, 'कनेक्ट' पर क्लिक करें और मज़े करें");

}

शून्य लूप ()

{

// इको प्राप्त डेटा

अगर (ब्लूफ्रूट.कनेक्टेड () && bleuart.notifyEnabled ())

{

इंट कमांड = bleuart.read ();

स्विच (कमांड) {

केस 'वी': {// संस्करण प्राप्त करें

कमांड वर्जन ();

टूटना;

}

केस 'एस': {// सेटअप आयाम, घटक, स्ट्राइड…

कमांडसेटअप ();

टूटना;

}

केस 'सी': {// रंग के साथ साफ़ करें

कमांड क्लियरकलर ();

टूटना;

}

केस 'बी': {// ब्राइटनेस सेट करें

कमांडसेटब्राइटनेस ();

टूटना;

}

केस 'पी': {// पिक्सेल सेट करें

कमांडसेट पिक्सेल ();

टूटना;

}

केस 'मैं': {// नई छवि प्राप्त करें

कमांड इमेज ();

टूटना;

}

}

}

}

शून्य स्वैपबफर ()

{

uint8_t *base_addr = पिक्सेलबफ़र;

इंट पिक्सेलइंडेक्स = 0;

के लिए (int j = 0; j <ऊंचाई; j++)

{

के लिए (int i = 0; i <चौड़ाई; i++) {

अगर (घटक == 3) {

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

}

अन्यथा {

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

}

base_addr+=घटक;

पिक्सेलइंडेक्स++;

}

पिक्सेलइंडेक्स + = स्ट्राइड - चौड़ाई; // पिक्सेलइंडेक्स को अगली पंक्ति में ले जाएँ (स्ट्राइड को ध्यान में रखें)

}

नियोपिक्सल.शो ();

}

शून्य कमांड वर्जन () {

Serial.println (F ("कमांड: वर्जन चेक"));

प्रेषण (NEOPIXEL_VERSION_STRING);

}

शून्य कमांडसेटअप () {

Serial.println (एफ ("कमांड: सेटअप"));

चौड़ाई = bleuart.read ();

ऊंचाई = bleuart.read ();

स्ट्राइड = bleuart.read ();

कंपोनेंट्सवैल्यू = bleuart.read ();

is400Hz = bleuart.read ();

नियोपिक्सलटाइप पिक्सेल टाइप;

पिक्सेल टाइप = कंपोनेंट्सवैल्यू + (is400Hz? NEO_KHZ400: NEO_KHZ800);

कंपोनेंट्स = (कंपोनेंट्स वैल्यू == NEO_RGB || कंपोनेंट्स वैल्यू == NEO_RBG || कंपोनेंट्स वैल्यू == NEO_GRB || कॉम्पोनेंट्स वैल्यू == NEO_GBR || कॉम्पोनेंट्स वैल्यू == NEO_BRG || कॉम्पोनेंट्स वैल्यू == NEO_BGR)? 3:4;

सीरियल.प्रिंटफ ("\ t आकार:% dx% d / n", चौड़ाई, ऊंचाई);

सीरियल.प्रिंटफ ("\ tstride:% d / n", स्ट्राइड);

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

Serial.printf ("\ tघटक:% d / n", घटक);

अगर (पिक्सेलबफर!= NULL) {

हटाएं पिक्सेलबफर;

}

uint32_t आकार = चौड़ाई * ऊंचाई;

पिक्सेलबफ़र = नया uint8_t [आकार * घटक];

neopixel.updateLength (आकार);

neopixel.updateType(pixelType);

neopixel.setPin (पिन);

// किया हुआ

प्रेषण ("ठीक है");

}

शून्य कमांडसेटब्राइटनेस () {

Serial.println (एफ ("कमांड: सेटब्राइटनेस"));

// मूल्य पढ़ें

uint8_t चमक = bleuart.read ();

// चमक सेट करें

neopixel.setBrightness (चमक);

// पिक्सल रिफ्रेश करें

स्वैपबफर ();

// किया हुआ

प्रेषण ("ठीक है");

}

शून्य कमांड क्लियरकलर () {

Serial.println (F ("कमांड: ClearColor"));

// रंग पढ़ें

uint8_t रंग [MAXCOMPONENTS];

के लिए (int j = 0; j <घटक;) {

अगर (ब्लूअर्ट.उपलब्ध ()) {

रंग [जे] = bleuart.read ();

जे++;

}

}

// सभी एलईडी को रंग में सेट करें

इंट आकार = चौड़ाई * ऊंचाई;

uint8_t *base_addr = पिक्सेलबफ़र;

के लिए (int i = 0; i <आकार; i++) {

के लिए (int j = 0; j <घटक; j++) {

*बेस_एड्र = रंग [जे];

बेस_एडीआर ++;

}

}

// स्वैप बफ़र्स

Serial.println (F ("क्लियरकलर पूरा हुआ"));

स्वैपबफर ();

अगर (घटक == 3) {

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

}

अन्यथा {

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

}

// किया हुआ

प्रेषण ("ठीक है");

}

शून्य कमांडसेट पिक्सेल () {

Serial.println (एफ ("कमांड: सेट पिक्सेल"));

// स्थिति पढ़ें

uint8_t x = bleuart.read ();

uint8_t y = bleuart.read ();

// रंग पढ़ें

uint32_t पिक्सेलऑफ़सेट = y*चौड़ाई+x;

uint32_t पिक्सेलडेटाऑफ़सेट = पिक्सेलऑफ़सेट*घटक;

uint8_t *base_addr = pixelBuffer+pixelDataOffset;

के लिए (int j = 0; j <घटक;) {

अगर (ब्लूअर्ट.उपलब्ध ()) {

*base_addr = bleuart.read ();

बेस_एडीआर ++;

जे++;

}

}

// रंग सेट करें

uint32_t neopixelIndex = y*stride+x;

uint8_t *pixelBufferPointer = pixelBuffer + pixelDataOffset;

uint32_t रंग;

अगर (घटक == 3) {

रंग = neopixel. Color(*pixelBufferPointer, *(pixelBufferPointer+1), *(pixelBufferPointer+2));

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

}

अन्यथा {

रंग = 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, रंग);

नियोपिक्सल.शो ();

// किया हुआ

प्रेषण ("ठीक है");

}

शून्य कमांड इमेज () {

Serial.printf ("कमांड: छवि% dx% d,% d,% d / n", चौड़ाई, ऊंचाई, घटक, स्ट्राइड);

// नया पिक्सेल बफर प्राप्त करें

इंट आकार = चौड़ाई * ऊंचाई;

uint8_t *base_addr = पिक्सेलबफ़र;

के लिए (int i = 0; i <आकार; i++) {

के लिए (int j = 0; j <घटक;) {

अगर (ब्लूअर्ट.उपलब्ध ()) {

*base_addr = bleuart.read ();

बेस_एडीआर ++;

जे++;

}

}

/*

अगर (घटक == 3) {

uint32_t अनुक्रमणिका = i*घटक;

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

}

*/

}

// स्वैप बफ़र्स

Serial.println (एफ ("छवि प्राप्त हुई"));

स्वैपबफर ();

// किया हुआ

प्रेषण ("ठीक है");

}

शून्य प्रेषण (चार कास्ट * प्रतिक्रिया) {

Serial.printf ("प्रतिक्रिया भेजें:% s / n", प्रतिक्रिया);

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

}

चरण 3: चरण 3: लैम्पशेड ख़रीदना

चरण 4: चरण 4: यह सब एक साथ खींचो