Zmiana koloru światła nocnego za pomocą Ardruino 101: 4 kroki (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:32

W tym projekcie wykonasz lampkę nocną za pomocą ardruino, Adafruit neo rgb Strips i drukarki 3D.

Zwróć uwagę, że to niemożliwe do złamania dotyczy wyłącznie mojego szkolnego projektu. Kod tego projektu jest oparty na innym projekcie. Powiedziawszy to, nie jestem ekspertem, jeśli chodzi o Ardruino.

Krok 1: Wymagania

Do tego projektu potrzebny będzie następujący sprzęt i narzędzia

Sprzęt komputerowy:

1 - A ardruino101 (w USA) lub Genuino101 (poza USA).

2 - Listwy LED NeoPixel rgb firmy adafruit (5 volt).

3 - złącze usb ardruino (typ B na złącze A).

4 - Oprogramowanie od Ardruino, Ardruino IDE W tym tutorialu będziemy używać wersji 1.8.5. Wymagania biblioteki oprogramowania to: 101, Adafruit NeoPixel i Madgwick.

5 -I obiekt do przechowywania twojego sprzętu. W tym przypadku będę używał drukarki 3D. Plik do tego wydruku 3D znajduje się w opisach o nazwie „Główka lampy”. Zauważ, że ten format pliku nie jest gotowy do druku 3D. W zależności od drukarek 3D, musisz najpierw uruchomić wyznaczone oprogramowanie do drukowania 3D na obiekcie 3D. Czasami skala wydruku 3D zostanie zresetowana. więc upewnij się, że średnica jest ustawiona na 11 cm na 11 cm.

6 - Podstawowy zestaw lutowniczy.

Krok 2: Zrozumienie sprzętu i oprogramowania

Ardruina/Genuino101

Dla wyjaśnienia, Ardruino101 i genuino101 są dokładnie takie same obok nazw. Oba mają te same specyfikacje i używają tego samego oprogramowania.

Ardruino101 posiada podstawowe specyfikacje, takie jak ardruino UNO i nie tylko. Główną cechą ardruino101 jest akcelerometr i żyroskop, których będziemy używać w naszym projekcie. Również ten typ ardruino ma swoją unikalną bibliotekę kodu o nazwie CurrieIMU (Internal Measurement Units), która jest zawarta w rozszerzeniu biblioteki 101.

Powiedziawszy to, porozmawiajmy o oprogramowaniu.

Oprogramowanie i biblioteki

Ardruino IDE używa Pythona jako głównego kodu źródłowego. jest to również główna platforma kodu, na której działa większość ardruino. Istnieje wiele samouczków online na temat korzystania z tego oprogramowania, więc polecam najpierw zapoznać się z nimi, jeśli jesteś nowy w tym programie.

Mając to na uwadze, biblioteki, z których korzystamy, są następujące:

Z menu Szkic > Dołącz bibliotekę > Zarządzaj bibliotekami… W polu wprowadzania tekstu wpisz

- 101 W standardzie ardruino 101 nie jest automatycznie dołączany do ardruino IDE. Potrzebujemy tego rozszerzenia biblioteki, aby zakodować nasz typ ardruino.

-Adafruit NeoPixel w celu kodowania naszych pasków Neo pixel.

-Madgwick W celu odczytania surowych danych i przeliczenia tych danych na surowe, pochylanie i przetaczanie.

Paski Neo RGB

Typ, którego będę używał, to typ 5 lub 5 V. Z tym 5v nie potrzebuję rozszerzonego źródła zasilania do sterowania moimi paskami. Zamiast tego będę używał mojego ardruino jako źródła zasilania do sterowania i podświetlania pasków.

Oto kilka wskazówek, które musisz znać, zanim zaczniesz korzystać z tych pasków.

Najpierw będziesz potrzebować taśm LED Neodigital RGB firmy adafruit. Ten rodzaj listew można kontrolować za pomocą kodów. Następnie musisz wiedzieć, że na tych paskach jest tył i przód. Ten tył i przód jest ważny dla lutowania. Upewnij się, że przylutowałeś przednią stronę, w której klawisz strzałki wskazuje z dala od końcówki.

Oto przewodnik, jak z nich korzystać.

Istnieją 3 punkty lutowania, o których należy pamiętać Połączenie uziemienia (GND), połączenie napięciowe (V) i połączenie pinowe (DIN).

Krok 3: Konfiguracja komponentów

Najpierw musisz wydrukować w 3D komponent, który znajdziesz w wymaganiach. W tym przypadku będę używał PLA. Upewnij się, że średnica całego obiektu wynosi 11 cm na 11 cm. Zapewni to, że ardruino i paski zmieszczą się w sferze. Zwróć uwagę, że każda drukarka 3D używa innego oprogramowania do obliczania procesu drukowania. Mając to na uwadze, plik, którego używasz, może być skalowany inaczej, więc miej to na uwadze.

Po drugie po wydrukowaniu upewnij się, że elementy są w stanie się zamknąć. Wydruki 3D tworzą razem kulę. Powinny ładnie pasować. Jeśli składnik ma się zgubić, przyklej taśmę do wewnętrznej strony, aby nasadka była wypełniona. A jeśli jest za gruby, użyj papieru ściernego.

Po trzecie, schematy dla ardruino i pasków są dość łatwe. Do podłączenia pasków do ardruino użyjesz 3 przewodów. Zauważ, że jedyne miejsca, które lutuję, to paski. nie na samym Ardruino.

GND idzie do GND

DIN idzie do Pina (w naszym przypadku pin6 na ardruino)

5V przechodzi do 5V

Upewnij się, że ilość pasków led, których używasz, jest ograniczona do 30. Jeśli to zrobisz, kod nie zostanie poprawnie wykonany. Możesz po prostu wyciąć wszelkie niepotrzebne paski wyświetlane ze znakiem nożyczek.

Po czwarte Wszystko powinno ładnie pasować do kuli. Mógłbyś tak, jak zrobiłem przecięcie między 1 z wydruków 3d, aby zobaczyć koryto i umieścić przezroczysty plastik na górze.

Krok 4: Kodowanie

Więc do tej pory powinieneś mieć wszystkie potrzebne komponenty w swojej bibliotece.

Oto kod, którego będziesz potrzebować, aby uruchomić projekt. Wynik powinien wyglądać jak link do filmu, który wysłałem na tej stronie.

Źródło tego kodu można znaleźć tutaj. Ten projekt obejmuje również niezbędne kroki w celu lepszego zrozumienia kodu i algorytmu kryjącego się za zastosowaniami.

#include #include #include #include

#define PIN 6 // 11 pikseli NeoPixel Strip

#define PIN1 7 // 1 pixel NeoPixel Strip #define NUMPIXELS 30 // Liczba pikseli #define SAMPLE_RATE 25 // Częstotliwość próbkowania dla akcelerometru i żyroskopu

// Konfiguracja Madgwick

filtr Madgwicka; unsigned long microsPerReading, microsPrevious; float accelScale, gyroScale;

// Konfiguracja NeoPixel

Adafruit_NeoPixel piksele = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); Adafruit_NeoPixel pikseleStatus = Adafruit_NeoPixel(1, 7, NEO_GRB + NEO_KHZ800);

// Przestrzenie kolorów

Konwerter RGB Konwerter rgb; podwójne h = 1; podwójne s = 1; podwójne v = 1; bajt rgb[3];

// Status lampy ruchu

// Stan 0 -> Select Hue - Pitch // Stan 1 -> Select Saturation - Roll // Stan 2 -> Select Value - Yaw // Stan 3 -> Fix color volatile int statusLamp = 0;

pusta konfiguracja () {

Serial.początek(9600);

// uruchom IMU i filtruj

CurieIMU.początek(); CurieIMU.setGyroRate(SAMPLE_RATE); CurieIMU.setAccelerometerRate(SAMPLE_RATE); filtr.początek(SAMPLE_RATE);

// Ustaw zakres akcelerometru na 2G

CurieIMU.setAccelerometerRange(2); // Ustaw zakres żyroskopu na 250 stopni/sekundę CurieIMU.setGyroRange(250);

CurieIMU.autoCalibrateAccelerometerOffset(X_AXIS, 0);

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

CurieIMU.attachInterrupt(wywołanie zwrotne);

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

// zainicjuj zmienne, aby tempo aktualizacji było prawidłowe

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

// Uruchom NeoPixel 11

piksele.początek(); piksele.pokaż();

// Uruchom NeoPixel 1

pikseleStatus.begin(); piksele.pokaż();

// Pokaż status w pikselach

setStatusPixel(statusLamp); }

pusta pętla () {

int aix, aiy, aiz; //akcelerometr int gix, giy, giz; topór pływający, ay, az; pływak gx, gy, gz; pływak, skok, zbaczanie; statyczny unsigned long microsTeraz;

// sprawdź, czy już czas na odczyt danych i aktualizację filtra

mikroTeraz = mikro(); if (mikroTeraz - mikroPoprzedni >= mikroOdczyt) {

// odczyt surowych danych z CurieIMU

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

// konwersja z surowych danych do grawitacji i jednostek stopni/sekundy

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

// zaktualizuj filtr, który oblicza orientację

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

// wydrukuj nagłówek, skok i rolkę

rolka = filter.getRoll(); wysokość = filtr.getPitch(); zbaczanie = filtr.getZyw();

// zwiększamy poprzedni czas, dzięki czemu utrzymujemy właściwe tempo

microsPrevious = microsPrevious + microsPerReading;

// Tylko w przypadku zmiany odcienia, nasycenia lub wartości

if (statusLamp wybierz Barwa if (pitch >= -90 && pitch <= 90 && statusLamp == 0) { // Przekształć kąt pitch = pitch + 90; // Uzyskuje współrzędne kolorów z kątów h = pitch / 180,0; }

// Ograniczenia kątów

// tylko przechylenie -90º do 90º = 180º // Stan 1 -> wybierz Nasycenie if (roll >= -90 && roll <= 90 && statusLamp == 1) { // Transform angle roll = roll + 90; // Uzyskuje współrzędne kolorów z kątów s = roll / 180.0; }

// Stan 2 -> wybierz Wartość

if (statusLamp == 2) { // odchylenie od 0º do 360º v = odchylenie / 360,0; }

// Konwertuj na rgb

rgbConverter.hsvToRgb(h, s, v, rgb); /* Serial.print("Kolor: "); druk.seryjny(h); Serial.print(" - "); odbitki.seryjne; Serial.print(" - "); Serial.print(v); Serial.println(" ");

Serial.print("Orientacja: ");

Serial.print(odchylenie); Serial.print(" "); Serial.print(rozstaw); Serial.print(" "); Serial.println(rolka); */

// Zmień kolor pikseli

for (int px = 0; px < NUMPIXELS; px++) { piksele.setPixelColor(px, piksele. Color(rgb[0], rgb[1], rgb[2])); piksele.pokaż(); } }

// Pokaż status w pikselach

setStatusPixel(statusLamp); } }

float convertRawAcceleration(int aRaw) {

// ponieważ używamy zakresu 2G // -2g mapuje do surowej wartości -32768 // +2g mapuje do surowej wartości 32767

zmiennoprzecinkowe a = (aRaw * 2,0) / 32768,0;

zwrócić; }

float konwersjaRawGyro(int gRaw) {

// ponieważ używamy zakresu 250 stopni/sekundy // -250 mapuje do surowej wartości -32768 // +250 mapuje do surowej wartości 32767

pływak g = (gRaw * 250,0) / 32768,0;

powrót g; }

statyczne void eventCallback()

{ // Wykryj stuknięcie we wszystkich osiach if (CurieIMU.getInterruptStatus(CURIE_IMU_TAP)) { Serial.print("Wykryto stuknięcie lampy stanu: "); Serial.println(lampka stanu);

// Zmień stan

stanLampa++;

// Stan początkowy

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

void setStatusPixel(int statusPx)

{ switch (statusPx) { case 0: pikseleStatus.setPixelColor(0, pikseleStatus. Color(150, 0, 0)); pikseleStatus.show(); przerwa; case 1: pikseleStatus.setPixelColor(0, pikseleStatus. Color(0, 150, 0)); pikseleStatus.show(); przerwa; case 2: pikseleStatus.setPixelColor(0, pikseleStatus. Color(0, 0, 150)); pikseleStatus.show(); przerwa; case 3: pikseleStatus.setPixelColor(0, pikseleStatus. Color(0, 0, 0)); pikseleStatus.show(); przerwa;

}

}