Mudança de cor da luz noturna usando Ardruino 101: 4 etapas (com imagens)

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

Neste projeto você fará um abajur usando ardruino, Adafruit neo rgb Strips e uma impressora 3D.

Observe que este intrutável é puramente para o meu projeto escolar. O código para este projeto é baseado em outro projeto. Com isso dito, não sou um especialista quando se trata de Ardruino.

Etapa 1: Requisitos

Para este projeto, você precisará do seguinte hardware e ferramentas

Hardware:

1 - Um ardruino101 (nos EUA) ou um Genuino101 (para fora dos EUA).

2 - Tiras de led NeoPixel rgb de adafruit (5 volts).

3 - Um conector USB ardruino (conector tipo B para A).

4 - Um software da Ardruino, Ardruino IDE Neste tutorial usaremos a versão 1.8.5. Os requisitos da biblioteca de software são: 101, Adafruit NeoPixel e Madgwick.

5 -E um objeto para alojar seu hardware. Nesse caso, estarei usando uma impressora 3D. O arquivo para esta impressão 3D está localizado nas descrições chamadas "Lamp Head". Observe que este formato de arquivo não está pronto para impressão 3D. Dependendo de suas impressoras 3D, você deve primeiro executar o software de impressão 3D designado no objeto 3D com antecedência. Às vezes, a escala da impressão 3D será redefinida. portanto, certifique-se de que o diâmetro esteja definido para 11 cm por 11 cm.

6 - Kit de solda básico.

Etapa 2: Compreender o Hardware e Software

Ardruin / Genuino101

Só para esclarecer, Ardruino101 e genuino101 são exatamente os mesmos ao lado dos nomes. Ambos têm as mesmas especificações e usam o mesmo software.

Ardruino101 possui as especificações básicas como o ardruino UNO e muito mais. A principal característica do ardruino101 é o acelerômetro e giroscópio que usaremos em nosso projeto. Além disso, este tipo de ardruino tem sua biblioteca de códigos exclusiva chamada CurrieIMU (Unidades de medição internas), que está incluída na extensão 101 da biblioteca.

Com isso dito, vamos falar sobre o software.

Software e bibliotecas

Ardruino IDE usa python como seu código-fonte principal. é também a plataforma de código principal onde a maioria dos ardruino é executada. Existem muitos tutoriais online sobre como usar este software, então eu recomendo que você pesquise-os primeiro se você for novo neste programa.

Com isso dito, as bibliotecas que estamos usando são as seguintes:

No menu Sketch,> Incluir Biblioteca> Gerenciar Bibliotecas… Na caixa de entrada de texto, digite

- 101 No standart, o ardruino 101 não é automaticamente incluído no IDE do ardruino. Precisamos dessa extensão de biblioteca para codificar nosso tipo de ardruino.

-Adafruit NeoPixel para codificar nossas tiras de pixel Neo.

-Madgwick A fim de ler os dados brutos e calcular esses dados para raw, pitch and roll.

Neo RGB tiras

O tipo que vou usar é um tipo de 5 voltagem ou 5v. Com este 5v eu não preciso de uma fonte de energia estendida para controlar minhas tiras. Em vez disso, usarei meu ardruino como fonte de energia para controlar e iluminar as tiras.

Aqui estão algumas dicas que você precisa saber antes de começar a ler estas tiras.

Primeiro você vai precisar de tiras de led RGB Neodigital de adafruit. Este tipo de faixa é cotrolável por meio de códigos. O próximo que você precisa saber é que há uma parte traseira e uma parte frontal nessas tiras. Esta parte traseira e frontal são importantes para a soldagem. Certifique-se de soldar o lado frontal onde a chave de seta está apontando para longe da ponta.

Aqui está um guia sobre como usá-los.

Existem 3 pontos de solda que você precisa ter em mente: conexão de aterramento (GND), conexão de tensão (V) e conexão de pino (DIN).

Etapa 3: Configurando os componentes

Primeiro você precisa imprimir em 3D o componente que você pode encontrar nos requisitos. Neste caso, estarei usando PLA. Certifique-se de que o diâmetro do objeto overal seja 11 cm por 11 cm. Isso garantirá que o ardruíno e as tiras caibam na capa. Note que cada impressora 3D utiliza diferentes softwares para calcular o seu processo de impressão. Com isso dito, o arquivo que você usa pode ser dimensionado de forma diferente, então tenha isso em mente.

Em segundo lugar após a impressão, certifique-se de que os componentes possam fechar. As impressões 3D juntas formam uma esfera. Eles devem se encaixar perfeitamente. Se o componente for perder, coloque um pouco de fita adesiva no lado interno para que a tampa seja preenchida. E se for grosso use lixa.

Em terceiro lugar, o skematichs para o ardruino e as tiras são bastante fáceis. Você usará 3 fios para conectar as tiras ao ardruino. Observe que os únicos lugares onde eu soldo são nas tiras. não no próprio Ardruino.

GND vai para GND

DIN vai para um pino (em nosso caso pino 6 no ardruino)

5V vai para 5V

Certifique-se de que a quantidade de tiras de led que você usa é de no máximo 30. Mais então isso e não conseguirá executar corretamente o código. Você pode simplesmente cortar qualquer tira desnecessária exibida com um sinal de tesoura.

Quarta Evrything deve se encaixar bem na esfera. Você poderia, como se eu fizesse uma interseção entre 1 da impressão 3D, a fim de ver a calha e coloque um plástico transparente no topo.

Etapa 4: codificação

Portanto, agora você deve ter todos os componentes necessários em sua biblioteca.

Aqui está o código de que você precisará para executar o projeto. O resultado deve ser semelhante ao link do vídeo que envio nesta página.

A fonte deste código pode ser encontrada aqui. Este projeto também inclui os passos necessários para entender melhor o código e o algarismo por trás dos usos.

#include #include #include #include

# define PIN 6 // 11 pixels NeoPixel Strip

#define PIN1 7 // 1 pixel NeoPixel Strip #define NUMPIXELS 30 // Número de píxels #define SAMPLE_RATE 25 // Taxa de amostragem para acelerômetro e giroscópio

// configuração Madgwick

Filtro Madgwick; longo sem sinal microsPerReading, microsPrevious; float accelScale, gyroScale;

// configuração NeoPixel

Adafruit_NeoPixel pixels = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); Adafruit_NeoPixel pixelsStatus = Adafruit_NeoPixel (1, 7, NEO_GRB + NEO_KHZ800);

// Espaços de cor

RGBConverter rgbConverter; duplo h = 1; s duplo = 1; duplo v = 1; byte rgb [3];

// Status Motion Lamp

// Estado 0 -> Selecionar Hue - Pitch // Estado 1 -> Selecionar Saturação - Rolar // Estado 2 -> Selecionar Valor - Yaw // Estado 3 -> Fixar cor volátil int statusLamp = 0;

void setup () {

Serial.begin (9600);

// inicie o IMU e filtre

CurieIMU.begin (); CurieIMU.setGyroRate (SAMPLE_RATE); CurieIMU.setAccelerometerRate (SAMPLE_RATE); filter.begin (SAMPLE_RATE);

// Defina a faixa do acelerômetro para 2G

CurieIMU.setAccelerometerRange (2); // Defina o intervalo do giroscópio para 250 graus / segundo CurieIMU.setGyroRange (250);

CurieIMU.autoCalibrateAccelerometerOffset (X_AXIS, 0);

CurieIMU.autoCalibrateAccelerometerOffset (Y_AXIS, 0); CurieIMU.autoCalibrateAccelerometerOffset (Z_AXIS, 1); CurieIMU.autoCalibrateGyroOffset ();

CurieIMU.attachInterrupt (eventCallback);

CurieIMU.setDetectionThreshold (CURIE_IMU_TAP, 950); CurieIMU.interrupts (CURIE_IMU_TAP);

// inicializar variáveis para atualizar o ritmo para corrigir a taxa

microsPerReading = 1000000 / SAMPLE_RATE; microsPrevious = micros ();

// Init NeoPixel 11

pixels.begin (); pixels.show ();

// Init NeoPixel 1

pixelsStatus.begin (); pixels.show ();

// Mostrar status em px

setStatusPixel (statusLamp); }

void loop () {

int aix, aiy, aiz; // acelerômetro int gix, giy, giz; float ax, ay, az; float gx, gy, gz; float roll, pitch, yaw; microsNow longo sem sinal estático;

// verifique se é hora de ler os dados e atualizar o filtro

microsNow = micros (); if (microsNow - microsPrevious> = microsPerReading) {

// ler dados brutos de CurieIMU

CurieIMU.readMotionSensor (aix, aiy, aiz, gix, giy, giz);

// converter dados brutos para unidades de gravidade e graus / segundo

ax = convertRawAcceleration (aix); ay = convertRawAcceleration (aiy); az = convertRawAcceleration (aiz); gx = convertRawGyro (gix); gy = convertRawGyro (giy); gz = convertRawGyro (giz);

// atualiza o filtro, que calcula a orientação

filter.updateIMU (gx, gy, gz, ax, ay, az);

// imprime o título, pitch e roll

roll = filter.getRoll (); pitch = filter.getPitch (); yaw = filter.getYaw ();

// incrementa o tempo anterior, para manter o ritmo adequado

microsPrevious = microsPrevious + microsPerReading;

// Somente se alterar matiz, saturação ou valor

if (statusLamp select Hue if (pitch> = -90 && pitch <= 90 && statusLamp == 0) {// Transformar ângulo pitch = pitch + 90; // Obtém cordões de cor dos ângulos h = pitch / 180,0;}

// Restrições de ângulos

// rolar apenas -90º a 90º = 180º // Estado 1 -> selecionar Saturação if (roll> = -90 && roll <= 90 && statusLamp == 1) {// Transformar ângulo roll = roll + 90; // Obtém cordinates de cor dos ângulos s = roll / 180.0; }

// Estado 2 -> selecione Valor

if (statusLamp == 2) {// yaw 0º a 360º v = yaw / 360.0; }

// Converter para rgb

rgbConverter.hsvToRgb (h, s, v, rgb); / * Serial.print ("Cor:"); Serial.print (h); Serial.print ("-"); Serial.print (s); Serial.print ("-"); Serial.print (v); Serial.println ("");

Serial.print ("Orientação:");

Serial.print (yaw); Serial.print (""); Serial.print (pitch); Serial.print (""); Serial.println (rolo); * /

// Mudar a cor dos pixels

para (int px = 0; px <NUMPIXELS; px ++) {pixels.setPixelColor (px, pixels. Color (rgb [0], rgb [1], rgb [2])); pixels.show (); }}

// Mostrar status em px

setStatusPixel (statusLamp); }}

float convertRawAcceleration (int aRaw) {

// já que estamos usando o intervalo 2G // -2g mapeia para um valor bruto de -32768 // + 2g mapeia para um valor bruto de 32767

float a = (aRaw * 2.0) / 32768.0;

return a; }

float convertRawGyro (int gRaw) {

// já que estamos usando o intervalo de 250 graus / segundos // -250 mapeia para um valor bruto de -32768 // +250 mapeia para um valor bruto de 32767

float g = (gRaw * 250,0) / 32768,0;

return g; }

static void eventCallback ()

{// Detectar tap em todos os eixos if (CurieIMU.getInterruptStatus (CURIE_IMU_TAP)) {Serial.print ("Tap detectado statusLamp:"); Serial.println (statusLamp);

// Mudar de estado

statusLamp ++;

// estado inicial

if (statusLamp> 3) {statusLamp = 0; }}}

void setStatusPixel (int statusPx)

{switch (statusPx) {case 0: pixelsStatus.setPixelColor (0, pixelsStatus. Color (150, 0, 0)); pixelsStatus.show (); pausa; caso 1: pixelsStatus.setPixelColor (0, pixelsStatus. Color (0, 150, 0)); pixelsStatus.show (); pausa; caso 2: pixelsStatus.setPixelColor (0, pixelsStatus. Color (0, 0, 150)); pixelsStatus.show (); pausa; caso 3: pixelsStatus.setPixelColor (0, pixelsStatus. Color (0, 0, 0)); pixelsStatus.show (); pausa;

}

}