Vraiment défi : 5 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Le monde moderne exige que les humains sortent du physique et vivent dans le numérique.

Avec l'apparition d'Al et la prolifération de la technologie, les gens font trop confiance à la machine et croient qu'elle est toujours correcte.

"Vraiment" est destiné à ébranler cette fausse confiance par la création d'un faux test de détecteur de mensonge. Les gens croiront facilement que Really fonctionne, mais lorsque de fausses réponses sont fournies, cela ébranlera leur confiance aveugle dans la technologie.

Étape 1: Étape 1: Souder le circuit

Parce que mes œuvres n'ont qu'une seule lumière, il est donc très facile à souder. Le problème principal est au début, je soude deux lumières, mais je n'ai pas couvert la partie exposition tout de suite. Ainsi, lorsque les deux fils se touchent. C'est court.

Étape 2: Étape 2: Écrivez le code

p.p1 {marge: 0.0px 0.0px 0.0px 0.0px; hauteur de ligne: 15,0 px; police: 12.0px Times; couleur: #000000; couleur d'arrière-plan: #ffffff}

p.p2 {marge: 0.0px 0.0px 0.0px 0.0px; hauteur de ligne: 15,0 px; police: 12.0px Times; couleur: #000000; couleur d'arrière-plan: #ffffff; min-height: 14,0 px} span.s1 {font-kerning: aucun}

Étape 2: écrivez le code

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

Ceci est un exemple pour nos modules Bluefruit LE basés sur nRF52

Achetez-en un aujourd'hui dans la boutique adafruit !

Adafruit investit du temps et des ressources pour fournir ce code open source, veuillez prendre en charge Adafruit et le matériel open source en achetant

produits d'Adafruit !

Licence MIT, consultez LICENCE pour plus d'informations

Tout le texte ci-dessus et l'écran de démarrage ci-dessous doivent être inclus dans

toute redistribution

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

/ Ce croquis est destiné à être utilisé avec le contrôle NeoPixel

// surface dans l'application mobile Bluefruit LE Connect d'Adafruit.

/

/ - Compilez et flashez ce croquis sur le nRF52 Feather

// - Ouvrir l'application Bluefruit LE Connect

// - Bascule vers l'utilitaire NeoPixel

// - Cliquez sur le bouton 'connecter' pour établir une connexion et

// envoyer les métadonnées sur la disposition des pixels

// - Utilisez l'utilitaire NeoPixel pour mettre à jour les pixels de votre appareil

/* NOTE: Ce sketch nécessitait au moins la version 1.1.0 d'Adafruit_Neopixel !!! */

#comprendre

#comprendre

#comprendre

#define NEOPIXEL_VERSION_STRING "Neopixel v2.0"

#define PIN 16 /* Pin utilisé pour piloter les NeoPixels */

#définir MAXCOMPONENTS 4

uint8_t *pixelBuffer = NULL;

uint8_t largeur = 0;

uint8_t hauteur = 0;

uint8_t foulée;

uint8_t composantsValue;

bool is400Hz;

composants uint8_t = 3; // seuls 3 et 4 sont des valeurs valides

Adafruit_NeoPixel neopixel = Adafruit_NeoPixel();

// Service BLE

BLEDfu bledfu;

BLEDis bledis;

BLEUart bleuart;

void setup()

{

Serial.begin(115200);

while (!Serial) delay(10); // pour nrf52840 avec usb natif

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

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

Serial.println();

Serial.println("Veuillez vous connecter en utilisant l'application Bluefruit Connect LE");

// Configuration des néopixels

neopixel.begin();

// Init Bluefruit

Bluefruit.begin();

Bluefruit.setTxPower(4); // Vérifiez bluefruit.h pour les valeurs prises en charge

Bluefruit.setName("Bluefruit52");

Bluefruit. Periph.setConnectCallback(connect_callback);

// Pour être cohérent, OTA DFU doit être ajouté en premier s'il existe

bledfu.begin();

// Configurer et démarrer le service d'informations sur le périphérique

bledis.setFabricant ("Adafruit Industries");

bledis.setModel("Bluefruit Feather52");

bledis.begin();

// Configurer et démarrer le service BLE UART

bleuart.begin();

// Configurer et lancer la publicité

startAdv();

}

void startAdv(void)

{

// Paquet publicitaire

Bluefruit. Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);

Bluefruit. Advertising.addTxPower();

// Inclut l'uuid bleuart 128 bits

Bluefruit. Advertising.addService(bleuart);

// Paquet de réponse d'analyse secondaire (facultatif)

// Puisqu'il n'y a pas de place pour 'Nom' dans le paquet publicitaire

Bluefruit. ScanResponse.addName();

/* Commencer la publicité

* - Activer la publicité automatique si déconnecté

* - Intervalle: mode rapide = 20 ms, mode lent = 152,5 ms

* - Le délai d'attente pour le mode rapide est de 30 secondes

* - Start(timeout) avec timeout = 0 fera de la publicité pour toujours (jusqu'à la connexion)

*

* Pour l'intervalle publicitaire recommandé

*

*/

Bluefruit. Advertising.restartOnDisconnect(true);

Bluefruit. Advertising.setInterval (32, 244); // en unité de 0,625 ms

Bluefruit. Advertising.setFastTimeout(30); // nombre de secondes en mode rapide

Bluefruit. Advertising.start(0); // 0 = Ne pas arrêter la publicité après n secondes

}

void connect_callback (uint16_t conn_handle)

{

// Récupère la référence à la connexion courante

BLEConnection* connection = Bluefruit. Connection(conn_handle);

char nom_central[32] = { 0 };

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

Serial.print("Connecté à ");

Serial.println(nom_central);

Serial.println("Veuillez sélectionner l'onglet 'Neopixels', cliquez sur 'Connect' et amusez-vous");

}

boucle vide()

{

// Echo des données reçues

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

{

commande int = bleuart.read();

commutateur (commande) {

case 'V': { // Obtenir la version

commandVersion();

Pause;

}

case 'S': { // Configuration des dimensions, des composants, de la foulée…

commandSetup();

Pause;

}

case 'C': { // Effacer avec la couleur

commandClearColor();

Pause;

}

case 'B': { // Définir la luminosité

commandSetBrightness();

Pause;

}

case 'P': { // Définir le pixel

commandSetPixel();

Pause;

}

case 'I': { // Recevoir une nouvelle image

commandeImage();

Pause;

}

}

}

}

annuler les tampons d'échange()

{

uint8_t *base_addr = pixelBuffer;

int pixelIndex = 0;

pour (int j = 0; j < hauteur; j++)

{

pour (int i = 0; i < largeur; i++) {

si (composants == 3) {

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

}

autre {

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

}

base_addr+=composants;

pixelIndex++;

}

pixelIndex += foulée - largeur; // Déplace pixelIndex à la ligne suivante (prend en compte la foulée)

}

neopixel.show();

}

void commandVersion() {

Serial.println(F("Commande: Vérification de la version"));

envoyerRéponse(NEOPIXEL_VERSION_STRING);

}

void commandSetup() {

Serial.println(F("Commande: Configuration"));

largeur = bleuart.read();

hauteur = bleuart.read();

foulée = bleuart.read();

composantsValeur = bleuart.read();

is400Hz = bleuart.read();

neoPixelType pixelType;

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

composants = (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", largeur, hauteur);

Serial.printf("\tstride: %d\n", foulée);

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

Serial.printf("\tcomponents: %d\n", composants);

if (pixelBuffer != NULL) {

delete pixelBuffer;

}

uint32_t taille = largeur*hauteur;

pixelBuffer = new uint8_t[taille*composants];

neopixel.updateLength(taille);

neopixel.updateType(pixelType);

neopixel.setPin(PIN);

// Terminé

sendResponse("OK");

}

void commandSetBrightness() {

Serial.println(F("Commande: Définir la luminosité"));

// Lire la valeur

uint8_t luminosité = bleuart.read();

// Régler la luminosité

neopixel.setBrightness(luminosité);

// Rafraîchir les pixels

swapBuffers();

// Terminé

sendResponse("OK");

}

void commandClearColor() {

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

// Lire la couleur

uint8_t couleur[MAXCOMPONENTS];

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

if (bleuart.available()) {

couleur[j] = bleuart.lire();

j++;

}

}

// Mettre toutes les leds en couleur

int taille = largeur * hauteur;

uint8_t *base_addr = pixelBuffer;

pour (int i = 0; i < taille; i++) {

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

*base_addr = couleur[j];

base_addr++;

}

}

// Échanger les tampons

Serial.println(F("ClearColor terminé"));

swapBuffers();

si (composants == 3) {

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

}

autre {

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

}

// Terminé

sendResponse("OK");

}

void commandSetPixel() {

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

// Position de lecture

uint8_t x = bleuart.read();

uint8_t y = bleuart.read();

// Lire les couleurs

uint32_t pixelOffset = y*largeur+x;

uint32_t pixelDataOffset = pixelOffset*composants;

uint8_t *base_addr = pixelBuffer+pixelDataOffset;

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

if (bleuart.available()) {

*base_addr = bleuart.read();

base_addr++;

j++;

}

}

// Définir les couleurs

uint32_t neopixelIndex = y* foulée+x;

uint8_t *pixelBufferPointer = pixelBuffer + pixelDataOffset;

uint32_t couleur;

si (composants == 3) {

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

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

}

autre {

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

neopixel.show();

// Terminé

sendResponse("OK");

}

void image de commande () {

Serial.printf("Commande: Image %dx%d, %d, %d\n", largeur, hauteur, composants, foulée);

// Recevoir un nouveau tampon de pixels

int taille = largeur * hauteur;

uint8_t *base_addr = pixelBuffer;

pour (int i = 0; i < taille; i++) {

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

if (bleuart.available()) {

*base_addr = bleuart.read();

base_addr++;

j++;

}

}

/*

si (composants == 3) {

uint32_t index = i*composants;

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

}

*/

}

// Échanger les tampons

Serial.println(F("Image reçue"));

swapBuffers();

// Terminé

sendResponse("OK");

}

void sendResponse(char const *response) {

Serial.printf("Envoyer la réponse: %s\n", réponse);

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

}

Étape 3: Étape 3: Acheter un abat-jour

Étape 4: Étape 4: Rassemblez le tout