Regtig uitdaging: 5 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:25

Die moderne wêreld vereis dat mense uit die fisiese kom en binne die digitale lewe.

Met die voorkoms van Al en die toename in tegnologie stel mense te veel vertroue in die masjien en glo dat dit altyd korrek is.

'Regtig' is bedoel om hierdie valse vertroue te laat skud deur 'n vals leuenverklikker -toets op te stel. Mense sal maklik glo dat Really werk, maar as valse antwoorde verskaf word, skud dit hul blinde vertroue in tegnologie.

Stap 1: Stap 1: Soldeer die stroombaan

Omdat my werke slegs een lig het, is dit baie maklik om te soldeer. Die grootste probleem is aan die begin, ek soldeer twee ligte, maar ek het nie die blootstellingsdeel onmiddellik gedek nie. Dus, as die twee drade onder mekaar raak. Dit kort.

Stap 2: Stap 2: Skryf die kode

p.p1 {marge: 0.0px 0.0px 0.0px 0.0px; lynhoogte: 15,0 px; lettertipe: 12.0px Times; kleur: #000000; agtergrondkleur: #ffffff}

p.p2 {marge: 0.0px 0.0px 0.0px 0.0px; lynhoogte: 15,0 px; lettertipe: 12.0px Times; kleur: #000000; agtergrond-kleur: #ffffff; min-hoogte: 14.0px} span.s1 {font-kerning: geen}

Stap 2: Skryf die kode neer

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

Dit is 'n voorbeeld vir ons nRF52 -gebaseerde Bluefruit LE -modules

Haal vandag een in die adafruitwinkel!

Adafruit belê tyd en hulpbronne in die verskaffing van hierdie open source -kode, Ondersteun asseblief Adafruit en open-source hardeware deur dit te koop

produkte van Adafruit!

MIT -lisensie, kyk na LISENSIE vir meer inligting

Alle teks hierbo en die spatskerm hieronder moet ingesluit word

enige herverdeling

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

/ Hierdie skets is bedoel om gebruik te word met die NeoPixel -beheer

// oppervlak in Adafruit se Bluefruit LE Connect -mobiele toepassing.

/

/ - Stel hierdie skets saam en plak dit op die nRF52 -veer

// - Maak die Bluefruit LE Connect -app oop

// - Skakel oor na die NeoPixel -nut

// - Klik op die 'verbind' -knoppie om 'n verbinding tot stand te bring en

// stuur die metadata oor die pixeluitleg

// - Gebruik die NeoPixel -program om die pixels op u toestel op te dateer

/* LET WEL: hierdie skets benodig ten minste weergawe 1.1.0 van Adafruit_Neopixel !!! */

#insluit

#insluit

#insluit

#definieer NEOPIXEL_VERSION_STRING "Neopixel v2.0"

#definieer PIN 16 / * Speld wat gebruik is om die NeoPixels te bestuur * /

#definieer MAXCOMPONENTS 4

uint8_t *pixelBuffer = NULL;

uint8_t breedte = 0;

uint8_t hoogte = 0;

uint8_t stap;

uint8_t komponenteValue;

bool is 400Hz;

uint8_t komponente = 3; // slegs 3 en 4 is geldige waardes

Adafruit_NeoPixel neopixel = Adafruit_NeoPixel ();

// BLE Diens

BLEDfu bledfu;

BLEDis bledis;

BLEUart bleuart;

leemte opstelling ()

{

Serial.begin (115200);

terwyl (! Serial) vertraging (10); // vir nrf52840 met native usb

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

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

Serial.println ();

Serial.println ("Verbind asseblief met die Bluefruit Connect LE -toepassing");

// Config Neopixels

neopixel.begin ();

// Init Bluefruit

Bluefruit.begin ();

Bluefruit.setTxPower (4); // Kyk na bluefruit.h vir ondersteunde waardes

Bluefruit.setName ("Bluefruit52");

Bluefruit. Periph.setConnectCallback (connect_callback);

// Om konsekwent te wees, moet OTA DFU eers bygevoeg word as dit bestaan

bledfu.begin ();

// Konfigureer en begin toestelinligtingsdiens

bledis.setManufacturer ("Adafruit Industries");

bledis.setModel ("Bluefruit Feather52");

bledis.begin ();

// Konfigureer en begin BLE UART -diens

bleuart.begin ();

// Stel op en begin adverteer

startAdv ();

}

leegte beginAdv (leeg)

{

// Advertensie pakkie

Bluefruit. Advertising.addFlags (BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);

Bluefruit. Advertising.addTxPower ();

// Sluit bleuart 128-bis uuid in

Bluefruit. Advertising.addService (bleuart);

// Sekondêre skanderingsreaksie -pakkie (opsioneel)

// Aangesien daar geen ruimte is vir 'Naam' in die advertensiepakket nie

Bluefruit. ScanResponse.addName ();

/* Begin adverteer

* - Aktiveer outomatiese advertensies as dit ontkoppel word

* - Interval: vinnige modus = 20 ms, stadige modus = 152,5 ms

* - Die tydsduur vir die vinnige modus is 30 sekondes

* - Begin (time -out) met time -out = 0 sal vir ewig adverteer (totdat dit verbind is)

*

* Vir aanbevole advertensie -interval

*

*/

Bluefruit. Advertising.restartOnDisconnect (waar);

Bluefruit. Advertising.setInterval (32, 244); // in eenheid van 0,625 ms

Bluefruit. Advertising.setFastTimeout (30); // aantal sekondes in die vinnige modus

Bluefruit. Advertising.start (0); // 0 = Moenie ophou adverteer na n sekondes nie

}

ongeldig connect_callback (uint16_t conn_handle)

{

// Kry die verwysing na die huidige verbinding

BLEConnection* verbinding = Bluefruit. Connection (conn_handle);

char central_name [32] = {0};

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

Serial.print ("gekoppel aan");

Serial.println (sentrale naam);

Serial.println ("Kies die oortjie 'Neopixels', klik op 'Koppel' en om pret te hê");

}

leemte lus ()

{

// Echo het data ontvang

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

{

int command = bleuart.read ();

skakelaar (opdrag) {

geval 'V': {// Kry weergawe

commandVersion ();

breek;

}

geval 'S': {// Stel afmetings, komponente, stap op …

commandSetup ();

breek;

}

geval 'C': {// Helder met kleur

commandClearColor ();

breek;

}

geval 'B': {// Stel helderheid in

commandSetBrightness ();

breek;

}

geval 'P': {// Stel Pixel

commandSetPixel ();

breek;

}

geval 'I': {// Ontvang nuwe beeld

commandImage ();

breek;

}

}

}

}

leegte ruilBuffers ()

{

uint8_t *base_addr = pixelBuffer;

int pixelIndex = 0;

vir (int j = 0; j <hoogte; j ++)

{

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

as (komponente == 3) {

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

}

anders {

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

}

base_addr+= komponente;

pixelIndex ++;

}

pixelIndex += stride - breedte; // Skuif pixelIndex na die volgende ry (neem die pas in ag)

}

neopixel.show ();

}

void commandVersion () {

Serial.println (F ("Opdrag: weergawekontrole"));

sendResponse (NEOPIXEL_VERSION_STRING);

}

void commandSetup () {

Serial.println (F ("Command: Setup"));

breedte = bleuart.read ();

hoogte = bleuart.read ();

stride = bleuart.read ();

componentsValue = bleuart.read ();

is400Hz = bleuart.read ();

neoPixelType pixelType;

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

komponente = (componentValue == 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", breedte, hoogte);

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

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

Serial.printf ("\ tkomponente: %d / n", komponente);

as (pixelBuffer! = NULL) {

verwyder pixelBuffer;

}

uint32_t grootte = breedte*hoogte;

pixelBuffer = nuwe uint8_t [grootte*komponente];

neopixel.updateLength (grootte);

neopixel.updateType (pixelType);

neopixel.setPin (PIN);

// Klaar

sendResponse ("OK");

}

void commandSetBrightness () {

Serial.println (F ("Command: SetBrightness"));

// Lees waarde

uint8_t helderheid = bleuart.read ();

// Stel die helderheid in

neopixel.setBrightness (helderheid);

// Verfris pixels

swapBuffers ();

// Klaar

sendResponse ("OK");

}

void commandClearColor () {

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

// Lees kleur

uint8_t kleur [MAXCOMPONENTS];

vir (int j = 0; j <komponente;) {

as (bleuart.available ()) {

kleur [j] = bleuart.read ();

j ++;

}

}

// Stel alle LED's in kleur

int grootte = breedte * hoogte;

uint8_t *base_addr = pixelBuffer;

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

vir (int j = 0; j <komponente; j ++) {

*base_addr = kleur [j];

base_addr ++;

}

}

// Ruil buffers om

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

swapBuffers ();

as (komponente == 3) {

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

}

anders {

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

}

// Klaar

sendResponse ("OK");

}

void commandSetPixel () {

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

// Lees posisie

uint8_t x = bleuart.read ();

uint8_t y = bleuart.read ();

// Lees kleure

uint32_t pixelOffset = y*breedte+x;

uint32_t pixelDataOffset = pixelOffset*komponente;

uint8_t *base_addr = pixelBuffer+pixelDataOffset;

vir (int j = 0; j <komponente;) {

as (bleuart.available ()) {

*base_addr = bleuart.read ();

base_addr ++;

j ++;

}

}

// Stel kleure

uint32_t neopixelIndex = y*stride+x;

uint8_t *pixelBufferPointer = pixelBuffer + pixelDataOffset;

uint32_t kleur;

as (komponente == 3) {

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

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

}

anders {

kleur = 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, kleur);

neopixel.show ();

// Klaar

sendResponse ("OK");

}

void commandImage () {

Serial.printf ("Command: Image %dx %d, %d, %d / n", breedte, hoogte, komponente, stap);

// Ontvang nuwe pixelbuffer

int grootte = breedte * hoogte;

uint8_t *base_addr = pixelBuffer;

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

vir (int j = 0; j <komponente;) {

as (bleuart.available ()) {

*base_addr = bleuart.read ();

base_addr ++;

j ++;

}

}

/*

as (komponente == 3) {

uint32_t indeks = i*komponente;

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

}

*/

}

// Ruil buffers om

Serial.println (F ("Beeld ontvang"));

swapBuffers ();

// Klaar

sendResponse ("OK");

}

void sendResponse (char const *response) {

Serial.printf ("Stuur antwoord: %s / n", antwoord);

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

}

Stap 3: Stap 3: Koop lampskerm

Stap 4: Stap4: trek alles saam