ფერის შეცვლა ღამის შუქის გამოყენებით Ardruino 101: 4 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:20

ამ პროექტში თქვენ გააკეთებთ ღამის ნათურას ardruino, Adafruit neo rgb Strips და 3D პრინტერის გამოყენებით.

გაითვალისწინეთ, რომ ეს გასართობი არის მხოლოდ ჩემი სკოლის პროექტისთვის. ამ პროექტის კოდი დაფუძნებულია სხვა პროექტზე. ამასთან, მე არ ვარ ექსპერტი, როდესაც საქმე ეხება არდრუინოს.

ნაბიჯი 1: მოთხოვნები

ამ პროექტისათვის დაგჭირდებათ შემდეგი ტექნიკა და ინსტრუმენტები

აპარატურა:

1 - ardruino101 (აშშ -ში) ან Genuino101 (აშშ -ს გარეთ).

2 - NeoPixel rgb led ზოლები ადაფრუტიდან (5 ვოლტი).

3 - ardruino USB კონექტორი (ტიპი B– დან A კონექტორი).

4 - პროგრამული უზრუნველყოფა Ardruino– დან, Ardruino IDE ამ გაკვეთილში ჩვენ ვიყენებთ 1.8.5 ვერსიას. პროგრამული ბიბლიოთეკის მოთხოვნებია: 101, Adafruit NeoPixel და Madgwick.

5 -და ობიექტი თქვენი ტექნიკის შესანახად. ამ შემთხვევაში მე ვიყენებ 3D პრინტერს. ამ 3D ბეჭდვის ფაილი მდებარეობს აღწერილობებში, სახელწოდებით "Lamp Head". გაითვალისწინეთ, რომ ეს ფაილის ფორმატი არ არის 3D ბეჭდვისთვის მზად. თქვენი 3D პრინტერებიდან გამომდინარე, თქვენ ჯერ უნდა გაუშვათ დანიშნული 3D ბეჭდვის პროგრამა 3D ობიექტზე. ზოგჯერ 3D ბეჭდვის მასშტაბი გადატვირთულია. ასე რომ, დარწმუნდით, რომ დიამეტრი არის 11 სმ 11 სმ.

6 - ძირითადი soldering ნაკრები.

ნაბიჯი 2: აპარატურის და პროგრამული უზრუნველყოფის გაგება

არდრუინი/Genuino101

უბრალოდ არდრუინო 101 და გენუინო 101 ზუსტად ერთნაირია სახელების გვერდით. ორივეს აქვს ერთი და იგივე მახასიათებლები და იყენებს ერთსა და იმავე პროგრამულ უზრუნველყოფას.

Ardruino101 ფლობს ძირითად მახასიათებლებს, როგორიცაა ardruino UNO და სხვა. Ardruino101– ის მთავარი მახასიათებელია ამაჩქარებელი და გიროსკოპი, რომელსაც ჩვენ ვიყენებთ ჩვენს პროექტში. ასევე ამ ტიპის არდრუინოს აქვს თავისი უნიკალური კოდის ბიბლიოთეკა სახელწოდებით CurrieIMU (შიდა გაზომვის ერთეულები), რომელიც შედის ბიბლიოთეკის გაფართოებაში 101.

ამის თქმით, მოდით ვისაუბროთ პროგრამულ უზრუნველყოფაზე.

პროგრამული უზრუნველყოფა და ბიბლიოთეკები

Ardruino IDE იყენებს პითონს, როგორც მთავარ წყაროს კოდს. ის ასევე არის მთავარი კოდი platvorm, სადაც ყველაზე მეტი არდრუინო მუშაობს. ინტერნეტში არის უამრავი გაკვეთილი, თუ როგორ გამოიყენოთ ეს პროგრამული უზრუნველყოფა, ამიტომ გირჩევთ, პირველ რიგში შეისწავლოთ ისინი, თუ ახალი ხართ ამ პროგრამით.

ამასთან, ბიბლიოთეკები, რომლებსაც ჩვენ ვიყენებთ, არის შემდეგი:

ესკიზის მენიუდან> ბიბლიოთეკის ჩართვა> ბიბლიოთეკების მართვა … ტექსტის შეყვანის ველში ჩაწერეთ

- 101 სტანდარტულად ardruino 101 ავტომატურად არ შედის ardruino IDE– ზე. ჩვენ გვჭირდება ბიბლიოთეკის გაფართოება, რათა დავაკოდიროთ ჩვენი არდრუინოს ტიპი.

-Adafruit NeoPixel იმისათვის, რომ კოდირებდეს ჩვენი ნეო პიქსელის ზოლები.

-მედგვიკი იმისათვის, რომ წაიკითხოთ ნედლეული მონაცემები და გამოითვალოთ ეს მონაცემები ნედლეულად, მოედანზე და როლში.

Neo RGB ზოლები

ტიპი, რომელსაც მე ვიყენებ არის 5 ძაბვის ან 5 ვ ტიპის. ამ 5V– ით მე არ მჭირდება გაფართოებული ენერგიის წყარო ჩემი ზოლების გასაკონტროლებლად. სამაგიეროდ მე ვიყენებ ჩემს არდრუინოს, როგორც ენერგიის წყაროს ზოლების გასაკონტროლებლად და გასანათებლად.

აქ არის რამოდენიმე რჩევა, რომელიც უნდა იცოდეთ სანამ დაიწყებთ ამ ზოლს.

პირველ რიგში დაგჭირდებათ ნეოდიგიტალური RGB led ზოლები ადაფრუტიდან. ამ ტიპის ზოლები კოტროლაბულია კოდების გამოყენებით. შემდეგი რაც თქვენ უნდა იცოდეთ არის ის, რომ ამ ზოლზე არის უკანა და წინა მხარე. ეს უკანა და წინა მხარე მნიშვნელოვანია შედუღებისათვის. დარწმუნდით, რომ შეაერთეთ წინა მხარე, სადაც ისრის ღილაკი წვერიდან არის დაშორებული.

აქ არის სახელმძღვანელო, თუ როგორ გამოიყენოთ ისინი.

არსებობს სამი შედუღების წერტილი, რომელიც უნდა გახსოვდეთ სახმელეთო კავშირი (GND), ძაბვის კავშირი (V) და Pin კავშირი (DIN).

ნაბიჯი 3: კომპონენტების დაყენება

პირველ რიგში თქვენ დაგჭირდებათ კომპონენტის 3D ბეჭდვა, რომელიც შეგიძლიათ იხილოთ მოთხოვნებში. ამ შემთხვევაში მე ვიყენებ PLA- ს. დარწმუნდით, რომ მთლიანი ობიექტის დიამეტრი არის 11 სმ 11 სმ. ეს უზრუნველყოფს იმას, რომ არდრუინო და ზოლები მოთავსდეს სასწრაფოდ. გაითვალისწინეთ, რომ თითოეული 3D პრინტერი იყენებს სხვადასხვა პროგრამულ უზრუნველყოფას ბეჭდვის პროცესის გამოსათვლელად. ამის თქმით, თქვენს მიერ გამოყენებული ფაილი შეიძლება განსხვავებული მასშტაბით იყოს, ასე რომ გაითვალისწინეთ.

დაბეჭდვის შემდეგ მეორე დარწმუნდით, რომ კომპონენტებს შეუძლიათ დახურონ. 3D ანაბეჭდები ერთად ქმნიან სფეროს. ისინი ლამაზად უნდა მოერგოს. თუკი კომპონენტი დაიკარგება, განათავსეთ რამოდენიმე ლენტი შიდა მხარეს, რომ დაიხუროს თავსახური. და თუ ეს სქელია გამოიყენეთ ქვიშაქვა.

მესამე სკემატიჩები არდრუინოსა და ზოლებისთვის საკმაოდ მარტივია. თქვენ იყენებთ 3 მავთულს, რომ დააკავშიროთ ზოლები არდრუინოსთან. გაითვალისწინეთ, რომ მხოლოდ ის ადგილები, სადაც ვასხურებ, არის ზოლზე. თვით არდრუინოზე.

GND გადადის GND– ზე

DIN გადადის პინზე (ჩვენს შემთხვევაში pin6 ardruino– ზე)

5V მიდის 5V– მდე

დარწმუნდით, რომ led ზოლების ოდენობა, რომელსაც თქვენ იყენებთ, არის 30 – ზე. თქვენ შეგიძლიათ უბრალოდ გაჭრათ ნებისმიერი უსუნო ზოლები, რომლებიც გამოსახულია მაკრატლის ნიშნით.

მეოთხე, ყველაფერი ლამაზად უნდა მოერგოს ამ სფეროს. თქვენ მოგეწონებათ მე გადავეწყვე 3D ბეჭდვის 1 – ს შორის, რათა ვნახო ბუდე და მოვათავსო პლასტმასის ზედა ნაწილი.

ნაბიჯი 4: კოდირება

ამ დროისთვის თქვენ უნდა გქონდეთ ბიბლიოთეკაში საჭირო ყველა კომპონენტი.

აქ არის კოდი, რომელიც დაგჭირდებათ პროექტის გასაშვებად. შედეგი უნდა გამოიყურებოდეს ვიდეოს ბმულზე, რომელსაც მე ვუგზავნი ამ გვერდზე.

ამ კოდის წყარო შეგიძლიათ იხილოთ აქ. ეს პროექტი ასევე მოიცავს ეტაპობრივ ნაბიჯებს, რათა უკეთ გავიგოთ კოდის და ალგარიტმის გამოყენება.

#ჩართეთ #ჩართეთ #ჩართეთ #ჩართეთ

#განსაზღვრეთ PIN 6 // 11 პიქსელი NeoPixel Strip

#განსაზღვრეთ PIN1 7 // 1 პიქსელი NeoPixel Strip #განსაზღვრეთ NUMPIXELS 30 // პიქსელების რიცხვი #განსაზღვრეთ SAMPLE_RATE 25 // შერჩევის მაჩვენებელი ამაჩქარებლისა და გიროსკოპისთვის

// მადგვიკის კონფიგურაცია

მადგვიკის ფილტრი; ხელმოუწერელი ხანგრძლივი microsPerReading, microsPrecious; float accelScale, gyroScale;

// NeoPixel კონფიგურაცია

Adafruit_NeoPixel პიქსელი = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); Adafruit_NeoPixel pixelsStatus = Adafruit_NeoPixel (1, 7, NEO_GRB + NEO_KHZ800);

// ფერადი სივრცეები

RGBConverter rgbConverter; ორმაგი h = 1; ორმაგი s = 1; ორმაგი v = 1; ბაიტი rgb [3];

// სტატუსის მოძრაობის ნათურა

// მდგომარეობა 0 -> აირჩიეთ ელფერი -მოედანზე // მდგომარეობა 1 -> აირჩიეთ გაჯერება -როლი // მდგომარეობა 2 -> აირჩიეთ მნიშვნელობა -ყბა // მდგომარეობა 3 -> შეასწორეთ ფერი არასტაბილური int statusLamp = 0;

void setup () {

სერიული.დაწყება (9600);

// დაიწყეთ IMU და გაფილტრეთ

CurieIMU.begin (); CurieIMU.setGyroRate (SAMPLE_RATE); CurieIMU.setAccelerometerRate (SAMPLE_RATE); filter. დასაწყისი (SAMPLE_RATE);

// დააყენეთ აქსელერომეტრის დიაპაზონი 2G

CurieIMU.setAccelerometerRange (2); // დააყენეთ გიროსკოპის დიაპაზონი 250 გრადუსზე/წამში 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. წყვეტს (CURIE_IMU_TAP);

// ცვლადების ინიციალიზაცია განახლების სისწრაფის დასადგენად

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

// Init NeoPixel 11

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

// ინიცირება NeoPixel 1

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

// სტატუსის ჩვენება პიქსელში

setStatusPixel (statusLamp); }

ბათილი მარყუჟი () {

int aix, aiy, aiz; // აქსელერომეტრი int gix, giy, giz; float ax, ay, az; float gx, gy, gz; float roll, pitch, yaw; სტატიკური ხელმოუწერელი გრძელი მიკრო ახლავე;

// შეამოწმეთ დროა წაიკითხოთ მონაცემები და განაახლოთ ფილტრი

microsNow = micros (); თუ (microsNow - microsPrevious> = microsPerReading) {

// წაიკითხეთ ნედლეული მონაცემები CurieIMU– დან

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

// ნედლი მონაცემებიდან გრავიტაციად და ხარისხზე/მეორე ერთეულად გადაყვანა

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

// განაახლეთ ფილტრი, რომელიც ითვლის ორიენტაციას

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

// დაბეჭდე სათაური, მოედანი და გააფართოვო

გააფართოვოს = filter.getRoll (); მოედანი = filter.getPitch (); yaw = filter.getYaw ();

// გაზრდა წინა დროს, ამიტომ ჩვენ ვიცავთ სათანადო ტემპს

microsPrevious = microsPrevious + microsPerReading;

// მხოლოდ იმ შემთხვევაში, თუ შეიცვლება ელფერი, გაჯერება ან მნიშვნელობა

if (statusLamp აირჩიეთ Hue if (მოედანი> = -90 && მოედანი <= 90 && statusLamp == 0) {// გარდაქმნის კუთხის მოედანს = მოედანზე + 90; // იღებს ფერს კორდინატებს კუთხეებიდან h = pitch / 180.0;}

// კუთხეების შეზღუდვები

// გააფართოვოს მხოლოდ -90º 90º = 180º // მდგომარეობა 1 -> შეარჩიეთ გაჯერება if (roll> = -90 && roll <= 90 && statusLamp == 1) {// კუთხის გარდაქმნა roll = roll + 90; // იღებს ფერის კორდინატებს კუთხეებიდან s = roll / 180.0; }

// მდგომარეობა 2 -> აირჩიეთ მნიშვნელობა

თუ (statusLamp == 2) {// yaw 0º 360º v = yaw / 360.0; }

// გადააქციე rgb

rgbConverter.hsvToRgb (h, s, v, rgb); /* Serial.print ("ფერი:"); სერიული. ბეჭდვა (თ); Serial.print (" -"); სერიული. ბეჭდვა (ები); Serial.print (" -"); Serial.print (v); Serial.println ("");

Serial.print ("ორიენტაცია:");

Serial.print (yaw); Serial.print (""); Serial.print (მოედანზე); Serial.print (""); Serial.println (როლი); */

// პიქსელების ფერის შეცვლა

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

// სტატუსის ჩვენება პიქსელში

setStatusPixel (statusLamp); }}

float convertRawAcceleration (int aRaw) {

// ვინაიდან ჩვენ ვიყენებთ 2G დიაპაზონს // -2 გ რუქებს -32768 ნედლეულის მნიშვნელობამდე // +2 გ რუქებს 32767 ნედლ მნიშვნელობამდე

float a = (aRaw * 2.0) / 32768.0;

დაბრუნება a; }

float convertRawGyro (int gRaw) {

// ვინაიდან ჩვენ ვიყენებთ 250 გრადუსი/წამის დიაპაზონს // -250 რუქა ნედლი ღირებულებით -32768 // +250 რუქა ნედლეულის მნიშვნელობამდე 32767

float g = (gRaw * 250.0) / 32768.0;

დაბრუნება გ; }

static void eventCallback ()

{// ყველა ღერძზე შეხების გამოვლენა, თუ (CurieIMU.getInterruptStatus (CURIE_IMU_TAP)) {Serial.print ("შეეხეთ აღმოჩენილ სტატუსს:"); Serial.println (statusLamp);

// მდგომარეობის შეცვლა

statusLamp ++;

// საწყისი მდგომარეობა

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

void setStatusPixel (int statusPx)

{switch (statusPx) {case 0: pixelsStatus.setPixelColor (0, pixelsStatus. Color (150, 0, 0)); pixelsStatus.show (); შესვენება; საქმე 1: pixelsStatus.setPixelColor (0, pixelsStatus. Color (0, 150, 0)); pixelsStatus.show (); შესვენება; საქმე 2: pixelsStatus.setPixelColor (0, pixelsStatus. Color (0, 0, 150)); pixelsStatus.show (); შესვენება; საქმე 3: pixelsStatus.setPixelColor (0, pixelsStatus. Color (0, 0, 0)); pixelsStatus.show (); შესვენება;

}

}