Realmente Desafio: 5 Passos

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:36

O mundo moderno exige que os humanos saiam do físico e vivam no digital.

Com o surgimento do Al e a proliferação da tecnologia, as pessoas confiam demais na máquina e acreditam que ela sempre estará correta.

“Realmente” tem como objetivo abalar essa falsa confiança por meio da criação de um falso detector de mentiras. As pessoas acreditarão facilmente que o Really está funcionando, mas quando respostas falsas forem fornecidas, sua confiança cega na tecnologia será abalada.

Etapa 1: Etapa 1: Solde o circuito

Porque o meu trabalho só tem uma luz, então é muito fácil de soldar. O principal problema é no início, eu soldo duas luzes, mas não cobri a parte de exposição imediatamente. Então, quando os dois fios se tocam. É curto.

Etapa 2: Etapa 2: escrever o código

p.p1 {margem: 0,0px 0,0px 0,0px 0,0px; altura da linha: 15,0px; fonte: 12,0px Times; cor: # 000000; cor de fundo: #ffffff}

p.p2 {margem: 0,0px 0,0px 0,0px 0,0px; altura da linha: 15,0px; fonte: 12,0px Times; cor: # 000000; cor de fundo: #ffffff; altura mínima: 14,0px} span.s1 {font-kerning: nenhum}

Etapa 2: Escreva o Código

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

Este é um exemplo para nossos módulos Bluefruit LE baseados em nRF52

Escolha um hoje na loja adafruit!

A Adafruit investe tempo e recursos fornecendo este código-fonte aberto, por favor, apoie Adafruit e hardware de código aberto comprando

produtos da Adafruit!

Licença do MIT, verifique a LICENÇA para obter mais informações

Todo o texto acima e a tela inicial abaixo devem ser incluídos em

qualquer redistribuição

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

/ Este esboço deve ser usado com o controle NeoPixel

// superfície no aplicativo móvel Bluefruit LE Connect da Adafruit.

/

/ - Compilar e atualizar este esboço para o nRF52 Feather

// - Abra o aplicativo Bluefruit LE Connect

// - Mude para o utilitário NeoPixel

// - Clique no botão 'conectar' para estabelecer uma conexão e

// envie os metadados sobre o layout de pixel

// - Use o utilitário NeoPixel para atualizar os pixels em seu dispositivo

/ * NOTA: Este esboço requer pelo menos a versão 1.1.0 do Adafruit_Neopixel !!! * /

#incluir

#incluir

#incluir

#define NEOPIXEL_VERSION_STRING "Neopixel v2.0"

#define PIN 16 / * Pin usado para conduzir os NeoPixels * /

# define MAXCOMPONENTS 4

uint8_t * pixelBuffer = NULL;

uint8_t largura = 0;

uint8_t height = 0;

uint8_t stride;

uint8_t componentsValue;

bool is400Hz;

componentes uint8_t = 3; // apenas 3 e 4 são valores válidos

Adafruit_NeoPixel neopixel = Adafruit_NeoPixel ();

// Serviço BLE

BLEDfu bledfu;

BLEDis bledis;

BLEUart bleuart;

void setup ()

{

Serial.begin (115200);

enquanto (! Serial) demora (10); // para nrf52840 com usb nativo

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

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

Serial.println ();

Serial.println ("Conecte usando o aplicativo Bluefruit Connect LE");

// Config Neopixels

neopixel.begin ();

// Init Bluefruit

Bluefruit.begin ();

Bluefruit.setTxPower (4); // Verifique bluefruit.h para obter os valores suportados

Bluefruit.setName ("Bluefruit52");

Bluefruit. Periph.setConnectCallback (connect_callback);

// Para ser consistente, o OTA DFU deve ser adicionado primeiro, se existir

bledfu.begin ();

// Configurar e iniciar o serviço de informações do dispositivo

bledis.setManufacturer ("Adafruit Industries");

bledis.setModel ("Bluefruit Feather52");

bledis.begin ();

// Configure e inicie o serviço BLE UART

bleuart.begin ();

// Configurar e começar a anunciar

startAdv ();

}

void startAdv (void)

{

// Pacote de publicidade

Bluefruit. Advertising.addFlags (BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);

Bluefruit. Advertising.addTxPower ();

// Inclui o uuid bleuart de 128 bits

Bluefruit. Advertising.addService (bleuart);

// Pacote de resposta à varredura secundária (opcional)

// Uma vez que não há espaço para 'Nome' no pacote de publicidade

Bluefruit. ScanResponse.addName ();

/ * Comece a anunciar

* - Ativar publicidade automática se desconectado

* - Intervalo: modo rápido = 20 ms, modo lento = 152,5 ms

* - O tempo limite para o modo rápido é de 30 segundos

* - Iniciar (tempo limite) com tempo limite = 0 anunciará para sempre (até conectado)

*

* Para intervalo de publicidade recomendado

*

*/

Bluefruit. Advertising.restartOnDisconnect (true);

Bluefruit. Advertising.setInterval (32, 244); // em unidade de 0,625 ms

Bluefruit. Advertising.setFastTimeout (30); // número de segundos no modo rápido

Bluefruit. Advertising.start (0); // 0 = Não pare de anunciar após n segundos

}

void connect_callback (uint16_t conn_handle)

{

// Obtenha a referência para a conexão atual

BLEConnection * connection = Bluefruit. Connection (conn_handle);

char central_name [32] = {0};

conexão-> getPeerName (central_name, sizeof (central_name));

Serial.print ("Conectado a");

Serial.println (central_name);

Serial.println ("Selecione a guia 'Neopixels', clique em 'Conectar' e divirta-se");

}

void loop ()

{

// Echo recebeu dados

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

{

comando int = bleuart.read ();

switch (comando) {

case 'V': {// Obter versão

commandVersion ();

pausa;

}

case 'S': {// Configurar dimensões, componentes, passo …

commandSetup ();

pausa;

}

case 'C': {// Limpar com cor

commandClearColor ();

pausa;

}

case 'B': {// Definir brilho

commandSetBrightness ();

pausa;

}

case 'P': {// Definir Pixel

commandSetPixel ();

pausa;

}

case 'I': {// Recebe nova imagem

commandImage ();

pausa;

}

}

}

}

void swapBuffers ()

{

uint8_t * base_addr = pixelBuffer;

int pixelIndex = 0;

para (int j = 0; j <altura; j ++)

{

para (int i = 0; i <largura; i ++) {

if (componentes == 3) {

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

}

outro {

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

}

base_addr + = componentes;

pixelIndex ++;

}

pixelIndex + = passo - largura; // Mova pixelIndex para a próxima linha (leve em consideração o passo)

}

neopixel.show ();

}

void commandVersion () {

Serial.println (F ("Comando: verificação de versão"));

sendResponse (NEOPIXEL_VERSION_STRING);

}

void commandSetup () {

Serial.println (F ("Comando: Configuração"));

largura = bleuart.read ();

altura = bleuart.read ();

stride = bleuart.read ();

componentsValue = 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", largura, altura);

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

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

Serial.printf ("\ tcomponentes:% d / n", componentes);

if (pixelBuffer! = NULL) {

delete pixelBuffer;

}

uint32_t size = largura * altura;

pixelBuffer = new uint8_t [componentes de tamanho *];

neopixel.updateLength (tamanho);

neopixel.updateType (pixelType);

neopixel.setPin (PIN);

// Feito

sendResponse ("OK");

}

void commandSetBrightness () {

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

// Ler valor

brilho uint8_t = bleuart.read ();

// Definir brilho

neopixel.setBrightness (brilho);

// Atualizar pixels

swapBuffers ();

// Feito

sendResponse ("OK");

}

void commandClearColor () {

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

// Leia a cor

uint8_t color [MAXCOMPONENTS];

para (int j = 0; j <componentes;) {

if (bleuart.available ()) {

cor [j] = bleuart.read ();

j ++;

}

}

// Defina todos os leds para a cor

tamanho interno = largura * altura;

uint8_t * base_addr = pixelBuffer;

para (int i = 0; i <tamanho; i ++) {

para (int j = 0; j <componentes; j ++) {

* base_addr = cor [j];

base_addr ++;

}

}

// Trocar buffers

Serial.println (F ("ClearColor concluído"));

swapBuffers ();

if (componentes == 3) {

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

}

outro {

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

}

// Feito

sendResponse ("OK");

}

void commandSetPixel () {

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

// Lê a posição

uint8_t x = bleuart.read ();

uint8_t y = bleuart.read ();

// Leia as cores

uint32_t pixelOffset = y * largura + x;

uint32_t pixelDataOffset = pixelOffset * componentes;

uint8_t * base_addr = pixelBuffer + pixelDataOffset;

para (int j = 0; j <componentes;) {

if (bleuart.available ()) {

* base_addr = bleuart.read ();

base_addr ++;

j ++;

}

}

// Definir cores

uint32_t neopixelIndex = y * passada + x;

uint8_t * pixelBufferPointer = pixelBuffer + pixelDataOffset;

uint32_t color;

if (componentes == 3) {

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

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

}

outro {

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

neopixel.show ();

// Feito

sendResponse ("OK");

}

void commandImage () {

Serial.printf ("Comando: Imagem% dx% d,% d,% d / n", largura, altura, componentes, passo);

// Recebe novo buffer de pixel

tamanho interno = largura * altura;

uint8_t * base_addr = pixelBuffer;

para (int i = 0; i <tamanho; i ++) {

para (int j = 0; j <componentes;) {

if (bleuart.available ()) {

* base_addr = bleuart.read ();

base_addr ++;

j ++;

}

}

/*

if (componentes == 3) {

uint32_t index = i * components;

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

}

*/

}

// Trocar buffers

Serial.println (F ("Imagem recebida"));

swapBuffers ();

// Feito

sendResponse ("OK");

}

void sendResponse (char const * response) {

Serial.printf ("Enviar resposta:% s / n", resposta);

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

}

Etapa 3: Etapa 3: Comprando Abajur

Etapa 4: Etapa 4: Junte tudo isso