Luce notturna che cambia colore con Ardruino 101: 4 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

In questo progetto realizzerai una lampada da notte utilizzando ardruino, strisce Adafruit neo rgb e una stampante 3D.

Nota che questo introvabile è puramente per il mio progetto scolastico. Il codice per questo progetto è basato su un altro progetto. Detto questo non sono un esperto quando si tratta di Ardruino.

Passaggio 1: requisiti

Per questo progetto avrai bisogno del seguente hardware e strumenti

Hardware:

1 - Un ardruino101 (negli Stati Uniti) o un Genuino101 (al di fuori degli Stati Uniti).

2 - Strisce led rgb NeoPixel di adafruit (5 volt).

3 - Un connettore usb ardruino (connettore da tipo B ad A).

4 - Un software di Ardruino, Ardruino IDE In questo tutorial utilizzeremo la versione 1.8.5. I requisiti della libreria software sono: 101, Adafruit NeoPixel e Madgwick.

5 -E un oggetto per ospitare il tuo hardware. In questo caso userò una stampante 3D. Il file per questa stampa 3D si trova nelle descrizioni chiamate "Lamp Head". Si noti che questo formato di file non è pronto per la stampa 3D. A seconda delle tue stampanti 3D, devi prima eseguire il software di stampa 3D designato sull'oggetto 3D. A volte la scala della stampa 3D si azzera. quindi assicurati che il diametro sia impostato su 11 cm per 11 cm.

6 - Kit di saldatura base.

Passaggio 2: comprensione dell'hardware e del software

Ardruin/Genuino101

Giusto per chiarire Ardruino101 e genuino101 sono esattamente gli stessi accanto ai nomi. Entrambi hanno le stesse specifiche e utilizzano lo stesso software.

Ardruino101 possiede le specifiche di base come ardruino UNO e altro ancora. La caratteristica principale di ardruino101 è l'accelerometro e il giroscopio che utilizzeremo nel nostro progetto. Anche questo tipo di ardruino ha la sua libreria di codici univoca chiamata CurrieIMU (Unità di misura interna) che è inclusa nell'estensione della libreria 101.

Detto questo, parliamo del software.

Software e librerie

Ardruino IDE utilizza Python come codice sorgente principale. è anche la piattaforma di codice principale in cui viene eseguita la maggior parte di ardruino. Ci sono molti tutorial online su come utilizzare questo software, quindi ti consiglio di ricercarli prima se sei nuovo in questo programma.

Detto questo, le librerie che utilizziamo sono le seguenti:

Dal menu Schizzo, > Includi libreria > Gestisci librerie… Nella casella di inserimento testo digita

- 101 Allo standard, ardruino 101 non è automaticamente incluso nell'IDE di ardruino. Abbiamo bisogno di questa estensione di libreria per codificare il nostro tipo ardruino.

-Adafruit NeoPixel per codificare le nostre strisce di pixel Neo.

-Madgwick Per leggere i dati grezzi e calcolare questi dati in grezzo, beccheggio e rollio.

Strisce Neo RGB

Il tipo che utilizzerò è un tipo 5 volt o 5v. Con questo 5v non ho bisogno di una fonte di alimentazione estesa per controllare le mie strisce. Invece userò il mio ardruino come fonte di alimentazione per controllare e illuminare le strisce.

Ecco alcuni suggerimenti che devi sapere prima di iniziare con queste strisce.

Per prima cosa avrai bisogno di una striscia led Neodigital RGB di adafruit. Questo tipo di strisce è controllabile tramite codici. Quindi devi sapere che c'è un lato posteriore e un lato anteriore su queste strisce. Questo lato anteriore e posteriore è importante per la saldatura. Assicurati di saldare il lato anteriore in cui il tasto freccia punta lontano dalla punta.

Ecco una guida su come usarli.

Ci sono 3 punti di saldatura che devi tenere a mente Connessione di terra (GND), Connessione di tensione (V) e Connessione pin (DIN).

Passaggio 3: configurazione dei componenti

Per prima cosa dovrai stampare in 3D il componente che puoi trovare nei requisiti. In questo caso userò PLA. Assicurati che il diametro dell'oggetto sia di 11 cm per 11 cm. Questo assicurerà che l'ardruino e le strisce si adattino alla forma. Nota che ogni stampante 3D utilizza diversi software per calcolare il suo processo di stampa. Detto questo, il file che usi potrebbe essere ridimensionato in modo diverso, quindi tienilo a mente.

Secondo dopo la stampa, assicurati che i componenti siano in grado di chiudersi. Le stampe 3D insieme formano una sfera. Dovrebbero adattarsi bene. Se il componente dovesse perdere, aggiungere del nastro adesivo sul lato interno in modo da riempire il tappo. E se è spessa, usa la carta vetrata.

Terzo, gli schemi per l'ardruino e le strisce sono abbastanza facili. Utilizzerai 3 fili per collegare le strisce all'ardruino. Nota che gli unici posti che ho saldato sono sulle strisce. non sull'Ardruino stesso.

GND va a GND

DIN va a un Pin (nel nostro caso pin6 su ardruino)

5V va a 5V

Assicurati che la quantità di strisce led che usi sia limitata a 30. Oltre a questo, non riuscirà a eseguire correttamente il codice. Puoi semplicemente tagliare le strisce non utilizzate visualizzate con un segno a forbice.

Quarto Tutto dovrebbe adattarsi bene alla sfera. Potresti fare un'intersezione tra 1 della stampa 3D per vedere attraverso e posizionare una plastica trasparente sulla parte superiore.

Passaggio 4: codifica

Quindi ormai dovresti avere tutti i componenti necessari nella tua libreria.

Ecco il codice necessario per eseguire il progetto. Il risultato dovrebbe essere simile al link del video che invio in questa pagina.

La fonte di questo codice può essere trovata qui. Questo progetto include anche i passaggi necessari per comprendere meglio il codice e l'algaritme dietro gli usi.

#include #include #include #include

#define PIN 6 // Striscia NeoPixel 11 pixel

#define PIN1 7 // 1 pixel NeoPixel Strip #define NUMPIXELS 30 // Numero di pixel #define SAMPLE_RATE 25 // Frequenza di campionamento per accelerometro e giroscopio

// Configurazione di Madgwick

filtro Madgwick; unsigned long microsPerReading, microsPrevious; float accelScale, gyroScale;

// Configurazione NeoPixel

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

// Spazi colore

Convertitore RGB Convertitore RGB; doppia h = 1; doppio s = 1; doppia v = 1; byte rgb[3];

// Spia movimento di stato

// Stato 0 -> Seleziona Tonalità - Pitch // Stato 1 -> Seleziona Saturazione - Roll // Stato 2 -> Seleziona Valore - Imbardata // Stato 3 -> Fix color volatile int statusLamp = 0;

void setup() {

Serial.begin(9600);

// avvia l'IMU e filtra

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

// Imposta l'intervallo dell'accelerometro su 2G

CurieIMU.setAccelerometerRange(2); // Imposta l'intervallo del giroscopio a 250 gradi/secondo 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);

// inizializza le variabili per stimolare gli aggiornamenti alla frequenza corretta

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

// Inizia NeoPixel 11

pixel.begin(); pixel.mostra();

// Inizia NeoPixel 1

pixelStatus.begin(); pixel.mostra();

// Mostra lo stato in px

setStatusPixel(statusLamp); }

ciclo vuoto() {

int aix, aiy, aiz; //accelerometro int gix, giy, giz; ascia galleggiante, ay, az; galleggiante gx, gy, gz; rollio galleggiante, beccheggio, imbardata; microsNow lungo senza segno statico;

// controlla se è il momento di leggere i dati e aggiornare il filtro

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

// legge i dati grezzi da CurieIMU

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

// converte i dati grezzi in unità di gravità e gradi/secondo

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

// aggiorna il filtro, che calcola l'orientamento

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

// stampa l'intestazione, il passo e il rollio

roll = filter.getRoll(); pitch = filter.getPitch(); imbardata = filter.getyaw();

// incrementa la volta precedente, così manteniamo il ritmo giusto

microsPrevious = microsPrevious + microsPerReading;

// Solo se cambia tonalità, saturazione o valore

if (statusLamp select Hue if (pitch >= -90 && pitch <= 90 && statusLamp == 0) { // Trasforma angolo pitch = pitch + 90; // Ottiene le coordinate dei colori dagli angoli h = pitch / 180.0; }

// Restrizioni sugli angoli

// roll only da -90º a 90º = 180º // Stato 1 -> seleziona Saturation if (roll >= -90 && roll <= 90 && statusLamp == 1) { // Trasforma angolo roll = roll + 90; // Ottiene le coordinate del colore dagli angoli s = roll / 180.0; }

// Stato 2 -> seleziona Valore

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

// Converti in rgb

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

Serial.print("Orientamento: ");

Serial.print(yaw); Serial.print(" "); Serial.print(passo); Serial.print(" "); Serial.println(rotolo); */

// Cambia il colore dei pixel

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

// Mostra lo stato in px

setStatusPixel(statusLamp); } }

float convertRawAcceleration(int aRaw) {

// poiché stiamo usando l'intervallo 2G // -2g mappa su un valore grezzo di -32768 // +2g mappa su un valore grezzo di 32767

float a = (aRaw * 2.0) / 32768.0;

restituire un; }

float convertRawGyro(int gRaw) {

// poiché stiamo utilizzando un intervallo di 250 gradi/secondi // -250 mappa su un valore grezzo di -32768 // +250 mappa su un valore grezzo di 32767

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

ritorno g; }

statico void eventCallback()

{ // Rileva il tocco in tutti gli assi if (CurieIMU.getInterruptStatus(CURIE_IMU_TAP)) { Serial.print("Tap rilevato statusLamp: "); Serial.println(statusLamp);

// Cambia stato

statusLamp++;

// Init state

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

void setStatusPixel(int statusPx)

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

}

}