ოპტიკურ-ბოჭკოვანი შუქები ტილოზე ბეჭდვა: 5 ნაბიჯი

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

ეს პროექტი დასძენს უნიკალურ ტრიალს სტანდარტული ტილოების ბეჭდვაზე. მე დავპროგრამე განათების 4 განსხვავებული რეჟიმი, მაგრამ თქვენ შეგიძლიათ მარტივად დაამატოთ მეტი. რეჟიმი იცვლება ყოველ ჯერზე როდესაც თქვენ გამორთავთ და ჩართავთ ნაცვლად ცალკე ღილაკისა, რათა მინიმუმამდე დაიყვანოს ჩარჩოს დაზიანება. ბატარეები უნდა მუშაობდეს 50+ საათზე - მე ნამდვილად არ ვარ დარწმუნებული, მაგრამ მე გავაკეთე მსგავსი პროექტი მეგობრისთვის და მან გამოიყენა 5x იმდენი შუქი და გაგრძელდა 20+ საათი ერთ ბატარეაზე.

მასალები

• ტილოს ბეჭდვა სამუშაო ადგილით - მე შევუკვეთე ჩემი https://www.easycanvasprints.com– დან, რადგან მათ ჰქონდათ კარგი ფასები და ღია ზურგი. სქელი 1.5”ჩარჩო იყო სრულყოფილი და მომცა ბევრი სივრცე ოპტიკურ ბოჭკოების ძაფების დასაწევად. დამატებით გსურთ სურათი, რომელიც გაძლევთ 3” 8”სამუშაო ადგილს ბატარეის პაკეტისთვის და მიკროკონტროლისთვის და LED ზოლებისთვის.
• LED ზოლის ნათურები - მე გამოვიყენე მისამართური WS2812 LED ზოლები. ნუ შეგეშინდებათ, მათი გამოყენება მართლაც ადვილია FastLED ან Neopixel ბიბლიოთეკებით! თქვენ ასევე შეგიძლიათ გამოიყენოთ ნებისმიერი სტანდარტული LED ზოლები, თქვენ უბრალოდ ვერ შეძლებთ თითოეული სინათლის განყოფილების ინდივიდუალურად გაკონტროლებას გაცილებით მეტი გაყვანილობის გარეშე.
• მიკროკონტროლერი - მე გამოვიყენე Arduino Uno, მაგრამ თქვენ შეგიძლიათ გამოიყენოთ თითქმის ყველაფერი ამ პროექტისთვის.
• ბატარეის პაკეტი - მე ეს შევუკვეთე eBay– დან (ჩინეთიდან) და მას ეწოდა "6 x 1.5V AA 2A CELL ბატარეის ბატარეების მფლობელი"
• ბოჭკოვანი ბოჭკოები - კიდევ ერთხელ, შეუკვეთეს ჩინეთიდან eBay– ზე - "PMMA Plastic Fiber Optic Cable End Grow Led Light DIY Decor" ან "PMMA End Glow Fiber Optic Cable for Star Ceiling Light Kit". მე გამოვიყენე ზომები 1 მმ და 1.5 მმ, მე ნამდვილად გირჩევთ გამოიყენოთ ამაზე მცირე.
• ჩართვა/გამორთვა გადამრთველი - "SPDT ჩართული/ჩართული 2 პოზიციის მინიატურული გადამრთველი გადამრთველები"
• მავთულის ორგანიზაციის კლიპები - ეს ხელს უწყობს ბოჭკოვანი ბოჭკოების ლამაზ და მოწესრიგებულ შენარჩუნებას.
• ქაფის დაფა, მყარი ძირითადი დამაკავშირებელი მავთული, სითბოს შემცირების მილი

ინსტრუმენტები

• დრემელი - გამოიყენება სურათის ჩარჩოში ჩართვის/გამორთვის გადასაბრუნებლად. ეს შეიძლება გაკეთდეს საბურღი და მართლაც დიდი ნაჭრით, მაგრამ მე ამას არ გირჩევ.
• შედუღების რკინა - მავთულის მიმაგრება LED ზოლზე
• ცხელი წებოს იარაღი - ფაქტიურად ამ პროექტის ყოველი ნაბიჯი
• დიდი სამკერვალო ნემსი - ტილოსა და ქაფის დაფაზე ხვრელების გასანათებლად

ნაბიჯი 1: ქაფის დაფა, ბატარეის პაკეტი და ჩართვა/გამორთვა

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

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

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

ნაბიჯი 2: მიკროკონტროლი და წრე

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

შეაერთეთ ბატარეის პაკეტის დადებითი დასასრული მიკროკონტროლერის VIN (ძაბვის შეყვანა) ისე, რომ ის იყენებს კონტროლერის ჩამონტაჟებულ ძაბვის რეგულატორს ძაბვის დასაწევად 5V– მდე. თუ ჩვენ უფრო მეტ ნათურას ვამუშავებდით, შეიძლება დაგჭირდეთ ჩვენი საკუთარი ძაბვის რეგულატორის გამოყენება, მაგრამ გაეროს უნდა შეეძლოს 5 LED- ის დამუშავება.

მე გამოვიყენე რეზისტორი მონაცემთა გამომავალსა და LED ზოლს შორის სიგნალის გასათანაბრებლად - რეზისტორის გარეშე შეიძლება მიიღოთ პიქსელების შემთხვევითი მოციმციმე. რეზისტორის ზომას ნამდვილად არ აქვს მნიშვნელობა, რაღაც 50Ω- დან 400Ω- მდე უნდა იმუშაოს.

ნაბიჯი 3: ოპტიკურ-ბოჭკოვანი განათება

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

1. გამოიყენეთ უმსხვილესი სამკერვალო ნემსი, თქვენ უნდა გააღოთ ხვრელი ტილოსა და ქაფის დაფის წინ. მე გირჩევ თავიდანვე გააღო ყველა ის ხვრელი, რომლითაც შეგიძლია გადაატრიალო და ნახო სად შეგიძლია/არ შეგიძლია შენი საკაბელო ორგანიზაციის კლიპების განთავსება
2. აიღეთ წყვილი ნემსის ცხვირსახოცი და აიღეთ ბოჭკოვანი ბოჭკო სანტიმეტრზე ნაკლები ბოლოდან
3. ამოიღეთ ბოჭკოვანი ბოჭკო იმ ხვრელში, რომელიც გააკეთეთ ნემსით
4. მარშრუტი გადააადგილეთ სხვადასხვა პლასტმასის სამაგრებს იქ, სადაც ის საჭიროზე ოდნავ გრძელია - ჩვენ მას მოგვიანებით დავჭრით
5. თქვენი ცხელი წებოს იარაღით დაბალი ტემპერატურის პარამეტრზე (თუ მას აქვს ეს შესაძლებლობა) ჩაასხით ცხელი წებოს წვეთი ოპტიკურ ბოჭკოზე, სადაც ის ქაფის დაფაზე გადის. ალტერნატიულად შეგიძლიათ გამოიყენოთ ეს ლურჯი წებოვანი ნივთები. ცხელი წებო გარკვეულწილად დეფორმირებას უკეთებს ძაფს, მაგრამ როგორც ჩანს, ის ოპტიკურ თვისებებს ძალიან არ ურევს
6. გათიშეთ ძაფი ტილოდან ოდნავ მოშორებით მავთულის საჭრელების გამოყენებით.

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

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

იმის გამო, რომ მე ვიყენებდი თეთრი ქაფის დაფას შავი ნაცვლად, ბევრი შუქი ანათებდა, როდესაც LED- ები იყო ჩართული. გამოსასწორებლად ჩავამალე ალუმინის ფოლგა შუქებსა და ტილოს შორის.

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

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

საბოლოოდ მე გამოვიყენე ცხელი წებო, რომ დავამატო პაკეტის ბოლო თითოეულ LED შუქზე. მე გამოვიყენე ბევრი ცხელი წებო ისე, რომ ბოჭკოები ფაქტიურად იღებდნენ შუქს თითოეული წითელი/მწვანე/ლურჯი დიოდის შუქზე - როდესაც ბოჭკოები მართლაც ახლოსაა შუქთან "თეთრი" ფერი (რომელიც რეალურად წითელი და მწვანე და ლურჯია) შემდეგ ზოგიერთი ბოჭკო იქნება მხოლოდ წითელი და ზოგი მწვანე, ნაცვლად იმისა, რომ ყველა იყოს თეთრი. ამის გაუმჯობესება შესაძლებელია ქაღალდის ნაჭრის ან სხვა რამის გამოსაყენებლად, მაგრამ ცხელი წებო საკმარისად კარგად მუშაობდა ჩემთვის.

ნაბიჯი 4: პროგრამირება

ამის პროგრამირებისას მე ვიყენებდი სამ წიგნებს

FastLED - დიდი ბიბლიოთეკა WS2812 LED ზოლების გასაკონტროლებლად (და მრავალი სხვა მიმართვადი LED ზოლები) -

Arduino დაბალი სიმძლავრე - არ ვიცი რამდენ ენერგიას დაზოგავს ეს რეალურად, მაგრამ მისი განხორციელება ძალიან ადვილი იყო და უნდა დაზოგოს მცირედი ენერგია იმ ფუნქციაზე, რომელიც არის მხოლოდ თეთრი შუქები და შემდეგ სამუდამოდ გადადება.

EEPROM - გამოიყენება პროექტის მიმდინარე რეჟიმის წასაკითხად/შესანახად. ეს საშუალებას აძლევს პროექტს გაზარდოს ფერადი რეჟიმი ყოველ ჯერზე როცა გამორთავთ და ჩართავთ, რაც გამორიცხავს რეჟიმის შესაცვლელად ცალკე ღილაკის საჭიროებას. EEPROM ბიბლიოთეკა დამონტაჟებულია ყოველთვის, როდესაც დააინსტალირებთ Arduino IDE- ს.

მე ასევე გამოვიყენე ესკიზი სხვისთვის დაყენებული შუქების მოციმციმედ. ის შემთხვევით ანათებს პიქსელს ძირითადი ფერიდან პიკის ფერში და შემდეგ უკან იხევს. https://gist.github.com/kriegsman/88954aae22b03a66… (ის ასევე იყენებს FastLED ბიბლიოთეკას)

მე ასევე გამოვიყენე vMicro მოდული Visual Studio– სთვის - ეს არის Arduino IDE– ს ამპეტირებული ვერსია. მას აქვს მრავალი სასარგებლო ავტომატური ფუნქცია და ხაზს უსვამს თქვენს კოდის პრობლემებს მისი შედგენის გარეშე. ღირს 15 დოლარი, მაგრამ იმდენად ღირს, თუ თქვენ აპირებთ Arduino– ს ერთზე მეტ პროექტს და ის გაიძულებთ გაეცნოთ Visual Studio– ს, რომელიც არის სუპერ ძლიერი პროგრამა.

(მე ასევე ვამაგრებ კოდის.ino ფაილს, რადგან Github Gist– ის ინსტრუქციული ჰოსტინგი ანადგურებს ბევრ ცარიელ ადგილს ფაილში)

Arduino კოდი მუშაობს 4 ფერის რეჟიმში Arduino UNO– ზე ზოგიერთი WS2812B LED ზოლის განათებისთვის FastLED ბიბლიოთეკის გამოყენებით

#ჩართეთ

#ჩართეთ

#ჩართეთ

// FastLED დაყენება

#განსაზღვრეთNUM_LEDS4

#definePIN3 // მონაცემთა პინი LED ზოლისთვის

CRGB ხელმძღვანელობს [NUM_LEDS];

// ციმციმის დაყენება

#defineBASE_COLORCRGB (2, 2, 2) // ფონის ძირითადი ფერი

#definePEAK_COLORCRGB (255, 255, 255) // პიკის ფერი მოციმციმე მდე

// თანხა, რათა გაიზარდოს ფერი თითოეული მარყუჟით, როგორც ის უფრო კაშკაშა ხდება:

#განსაზღვრეთDELTA_COLOR_UPCRGB (4, 4, 4)

// რაოდენობის შესამცირებლად ფერი თითოეული მარყუჟით, როდესაც ის ბნელდება:

#განსაზღვრეთDELTA_COLOR_DOWNCRGB (4, 4, 4)

// თითოეული პიქსელის შანსი იწყებს გაბრწყინებას.

// 1 ან 2 = რამდენიმე გამაღიავებელი პიქსელი ერთდროულად.

// 10 = ბევრი პიქსელი ერთდროულად ანათებს.

#განსაზღვრეთ CHANCE_OF_TWINKLE2

enum {SteadyDim, GettingBrighter, GettingDimmerAgain};

uint8_t PixelState [NUM_LEDS];

ბაიტი runMode;

ბაიტი globalBright = 150;

ბაიტი globalDelay = 20; // დაცინვის სიჩქარე მოციმციმე

ბაიტის მისამართი = 35; // მისამართი გაშვების რეჟიმის შესანახად

voidsetup ()

{

FastLED.addLeds (leds, NUM_LEDS);

FastLED.setCorrect (TypicalLEDStrip);

//FastLED.setMaxPowerInVoltsAndMilliamps(5, maxMilliamps);

FastLED.setBrightness (globalBright);

// მიიღეთ რეჟიმი გასაშვებად

runMode = EEPROM.read (მისამართი);

// გაზარდეთ მუშაობის რეჟიმი 1 -ით

EEPROM.write (მისამართი, runMode + 1);

}

voidloop ()

{

გადართვა (runMode)

{

// მყარი თეთრი

case1: fill_solid (leds, NUM_LEDS, CRGB:: თეთრი);

FastLED.show ();

DelayForever ();

შესვენება;

// ციმციმებ ნელა

საქმე 2: FastLED.setBrightness (255);

გლობალური დაგვიანებით = 10;

TwinkleMapPixels ();

შესვენება;

// სწრაფად მოციმციმე

საქმე 3: FastLED.setBrightness (150);

გლობალური დაგვიანებით = 2;

TwinkleMapPixels ();

შესვენება;

//Ცისარტყელა

შემთხვევა 4:

RunRainbow ();

შესვენება;

// ინდექსი დიაპაზონის მიღმა, გადააყენეთ 2 -ზე და შემდეგ გაუშვით რეჟიმი 1.

// არდუინოს გადატვირთვისას ის გაუშვებს 2 რეჟიმს, მაგრამ ამ დროისთვის გაუშვებს რეჟიმს 1

ნაგულისხმევი:

EEPROM.write (მისამართი, 2);

runMode = 1;

შესვენება;

}

}

voidRunRainbow ()

{

ბაიტი *გ;

uint16_t i, j;

სანამ (მართალია)

{

for (j = 0; j <256; j ++) {// 1 ფერის ციკლი ბორბალზე

for (i = 0; i <NUM_LEDS; i ++) {

c = ბორბალი (((i * 256 / NUM_LEDS) + კ) & 255);

setPixel (i, *c, *(c + 1), *(c + 2));

}

FastLED.show ();

დაგვიანება (გლობალური დაგვიანებით);

}

}

}

ბაიტი * ბორბალი (ბაიტი WheelPos) {

სტატიკური ბაიტი c [3];

თუ (WheelPos <85) {

c [0] = WheelPos * 3;

c [1] = 255 - WheelPos * 3;

c [2] = 0;

}

elseif (WheelPos <170) {

WheelPos -= 85;

c [0] = 255 - WheelPos * 3;

c [1] = 0;

c [2] = WheelPos * 3;

}

სხვა {

WheelPos -= 170;

c [0] = 0;

c [1] = WheelPos * 3;

c [2] = 255 - WheelPos * 3;

}

დაბრუნება გ;

}

voidTwinkleMapPixels ()

{

InitPixelStates ();

სანამ (მართალია)

{

for (uint16_t i = 0; i <NUM_LEDS; i ++) {

if (PixelState == SteadyDim) {

// ეს პიქსელები ამჟამად არის: SteadyDim

// ასე რომ, ჩვენ შემთხვევით განვიხილავთ, რომ იგი დაიწყოს უფრო ნათელი

if (random8 () <CHANCE_OF_TWINKLE) {

PixelState = GettingBrighter;

}

}

elseif (PixelState == GettingBrighter) {

// ეს პიქსელები ამჟამად არის: GettingBrighter

// ასე რომ, თუ ის პიკის ფერშია, გადართეთ ისევ დაბნელებაზე

თუ (leds > = PEAK_COLOR) {

PixelState = GettingDimmerAgain;

}

სხვა {

// სხვაგვარად, უბრალოდ გააგრძელე ის:

leds += DELTA_COLOR_UP;

}

}

სხვა {// ისევ დაბნელდება

// ეს პიქსელები ამჟამად არის: GettingDimmerAgain

// ასე რომ, თუ ის დაუბრუნდა ძირითად ფერს, გადართეთ იგი სტაბილურ დაბნელებაზე

თუ (leds <= BASE_COLOR) {

leds = BASE_COLOR; // გადატვირთეთ ზუსტი საბაზისო ფერი, იმ შემთხვევაში, თუ ჩვენ გადავაჭარბებთ

PixelState = SteadyDim;

}

სხვა {

// წინააღმდეგ შემთხვევაში, უბრალოდ გააგრძელეთ მისი დაბინდვა:

leds -= DELTA_COLOR_DOWN;

}

}

}

FastLED.show ();

FastLED.delay (globalDelay);

}

}

voidInitPixelStates ()

{

memset (PixelState, sizeof (PixelState), SteadyDim); // ყველა პიქსელის ინიციალიზაცია SteadyDim– ზე.

fill_solid (leds, NUM_LEDS, BASE_COLOR);

}

voidDelayForever ()

{

სანამ (მართალია)

{

დაგვიანება (100);

LowPower.powerDown (SLEEP_FOREVER, ADC_OFF, BOD_OFF);

}

}

voidshowStrip () {

FastLED.show ();

}

voidsetPixel (int Pixel, ბაიტი წითელი, ბაიტი მწვანე, ბაიტი ლურჯი) {

// FastLED

leds [პიქსელი].რ = წითელი;

leds [Pixel].g = მწვანე;

leds [Pixel].b = ლურჯი;

}

rawFiberOptic_ClemsonPic.ino ნახვა hosted ერთად GitHub

ნაბიჯი 5: საბოლოო პროდუქტი

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