第1步：材料

結構材料：

DIY ukelele安裝套件（可能是另一種不同的套件）由以下組成：

1- Body。

2-neck。

3-Saddle

4-Rope Support

5-Bridge

6-String nut 。

7-機頭固定環(huán)（x4）。

8機頭（x4）。

9-機頭安裝螺絲（x8）用于機橋（x2）的10個安裝螺釘。

11-用于橋接安裝螺釘（x2）的蓋帽。

12弦（ x4）。

電子資料：

NANO Arduino。

Leds輪WS2812。

加速度計BMA220（可選）。

電池連接器。

9V電池。

轉移。

其他

木器清漆。

魔術貼。

焊錫。

用于上漆的保護性塑料。

熱熔硅膠。

工具：

激光雕刻。

砂紙

星形螺絲刀。

畫筆。

熱熔槍。

錫烙鐵。

第2步：自定義尤克里里琴

為了使我們的夏威夷四弦琴成型，我們可以在身體上用激光切割機雕刻圖紙。在沒有該工具的情況下，我們可以繪制它。

我們選擇的圖片是第一個出現(xiàn)的圖片。

首先，我們必須設計繪圖模板來進行雕刻。

為了實現(xiàn)這一點，我們將使用一個名為“Inkscape”的軟件，我們可以從這個鏈接獲得：https：//inkscape.org/es/descargas/。

使用它，我們必須調(diào)整我們想要使用的圖片，就像我們在第二張圖片中顯示的那樣。您可以看到我們已經(jīng)旋轉了初始圖像，可以用儀器的圓圈調(diào)整手的cicle。就像我們之前說的那樣，你可以放任何圖像。

第3步：使用Inkscape對圖像進行矢量化

我們將看到如何從像素圖創(chuàng)建矢量文件（jpg，png，Inkscape可以打開的任何柵格格式）。

Inkscape Inkscape是一個開源矢量圖形編輯器，正如標題所暗示的，這是我將用來矢量化徽標的工具。矢量化步驟這些步驟對于我們可能想要進行的任何矢量化都是常見的。

在Inkscape中打開圖像

打開跟蹤位圖工具路徑 - 》跟蹤位圖

圍繞跟蹤位圖選項進行游戲

運行跟蹤

清理結果（如有必要）

注意“游戲”部分。我不是追蹤專家，所以我把這個工具當作一個帶旋鈕和燈光的黑盒子，扭曲和改變直到我得到最好的結果

第4步：徽標雕刻

為此，重要的是要有一個表面的輪廓，其上的雕刻將制作。

為了制作雕刻，我們將使用‘T2Laser’軟件。我們可以從以下網(wǎng)站獲取此軟件：http：//descargar.cnet.com/windows/t2-laser/3260-2.。.

一旦我們打開軟件，我們必須加載圖像我們在最后一步創(chuàng)建了。然后，按“控制激光”按鈕，出現(xiàn)cnc控件。

兩張照片顯示了我們激光切割機雕刻的過程和結果。

步驟5：打磨和上漆

為了讓我們的夏威夷四弦琴明亮，并且沒有粗糙的層，我們可以順利地打磨構成我們樂器的兩個部分，因為我們可能會損壞已經(jīng)制作的圖紙（如果您選擇繪制尤克里里琴，則必須先將其打磨）。然后我們將清漆我們的兩個部分，使它們獲得更深的顏色，木材呈現(xiàn)出更大的阻力。我們可以使用普通的木材清漆，它不需要特殊。

一旦我們有清漆，我們將它與少量溶劑混合，使其溶解一點。接下來，我們用刷子將混合物涂在頸部和儀器的主體上，讓它干燥。

如果我們發(fā)現(xiàn)產(chǎn)品需要第二層涂層，我們可以將這兩個部分打磨一下重新涂抹一層稀釋的清漆。

**預防措施：清漆是一種化學產(chǎn)品，因此必須在通風處進行此過程，戴上口罩以避免吸入異味和護目鏡。

我們需要能夠正常工作的材料是照片中出現(xiàn)的材料。主要是我們將使用刷子，清漆罐（在我們的情況下是紅色），一點溶劑和視覺保護。最重要的是在通風良好的空間工作。

第6步：硬件

我們帶有Arduino，acelerometer和帶LED指示燈的銘牌將在一個小支架中引入，以避免所有組件在儀器中移動。

我們還添加了一個電池座和一個開關，使其更舒適，我們不使用儀器時也不會耗盡電池。我們將這個支架用一塊維可牢尼龍搭扣（它也適用于硅膠和熱熔槍）連接到尤克里里琴琴體的內(nèi)表面。

另一方面，LED輪小于孔，所以它會下降。已經(jīng)設計了一個支持，以便它可以很好地執(zhí)行其功能。

步驟7：軟件

為了給我們的夏威夷四弦琴做一個特殊的裝飾，我們可以通過一個LED輪來增加燈光效果。我們將使用WS2812，但您可以按照數(shù)據(jù)表的說明使用任何其他產(chǎn)品。我們也將使用一個acelerometer（BMA220），它可以讓我們產(chǎn)生重力效應。

事實上，我們將有4個光源，包括在Arduino的名為“Adafruit”的計算機庫中。為此，我們必須在三個組件之間做出正確的共識：Arduino NANO，WS2812和BMA220，就像出現(xiàn)在第一張圖片中一樣。

紅色線用于供電，GND黑色和其余部分是正確操作所必需的連接。

我們用于燈具的代碼附在一個名為“play_of_light_v0”的文件中。鮑”。確保已包含必要的庫以正確操作程序。我們在電路外部添加的電池必須具有9V的最小電壓，我們必須確保它能夠提供為整個電路供電所需的最小電流。

//Variables contador e interrupción

int counter;

//Variables Ejemplo gravedad

#include

#include

#include

#define NUMBER_OF_LEDS_ON_RING 16

#define NEOPIXEL_RING_DATA_PIN 9

byte Version［3］;

int8_t x_data;

int8_t y_data;

int8_t z_data;

byte range=0x00;

float divi=16;

float x，y，z;

float pi = 3.14159265359;

float nx，ny，angle;

int led， previousLed;

QueueList ledQueue;

Adafruit_NeoPixel neoring = Adafruit_NeoPixel（NUMBER_OF_LEDS_ON_RING， NEOPIXEL_RING_DATA_PIN， NEO_GRB + NEO_KHZ800）;

//Variables Luces arcoiris

#include

#ifdef __AVR__

#include

#endif

#define PIN 9

// Parameter 1 = number of pixels in strip

// Parameter 2 = Arduino pin number （most are valid）

// Parameter 3 = pixel type flags， add together as needed：

// NEO_KHZ800 800 KHz bitstream （most NeoPixel products w/WS2812 LEDs）

// NEO_KHZ400 400 KHz （classic ‘v1’ （not v2） FLORA pixels， WS2811 drivers）

// NEO_GRB Pixels are wired for GRB bitstream （most NeoPixel products）

// NEO_RGB Pixels are wired for RGB bitstream （v1 FLORA pixels， not v2）

// NEO_RGBW Pixels are wired for RGBW bitstream （NeoPixel RGBW products）

Adafruit_NeoPixel strip = Adafruit_NeoPixel（16， PIN， NEO_GRB + NEO_KHZ800）;

// IMPORTANT： To reduce NeoPixel burnout risk， add 1000 uF capacitor across

// pixel power leads， add 300 - 500 Ohm resistor on first pixel‘s data input

// and minimize distance between Arduino and first pixel. Avoid connecting

// on a live circuit.。.if you must， connect GND first.

//Variables Rueda de colores

// NeoPixel Ring simple sketch （c） 2013 Shae Erisson

// released under the GPLv3 license to match the rest of the AdaFruit NeoPixel library

#include

#ifdef __AVR__

#include

#endif

// Which pin on the Arduino is connected to the NeoPixels？

// On a Trinket or Gemma we suggest changing this to 1

#define PIN 9

// How many NeoPixels are attached to the Arduino？

#define NUMPIXELS 16

// When we setup the NeoPixel library， we tell it how many pixels， and which pin to use to send signals.

// Note that for older NeoPixel strips you might need to change the third parameter--see the strandtest

// example for more information on possible values.

Adafruit_NeoPixel pixels = Adafruit_NeoPixel（NUMPIXELS， PIN， NEO_GRB + NEO_KHZ800）;

int delayval = 50; // delay for 50ms

//Variables colores aleatorios

#include

#ifdef __AVR__

#include

#endif

#define PIN 9

#define NUM_LEDS 16

#define BRIGHTNESS 200

//Adafruit_NeoPixel strip = Adafruit_NeoPixel（NUM_LEDS， PIN， NEO_GRBW + NEO_KHZ800）;

byte neopix_gamma［］ = {

0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0，

0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 0， 1， 1， 1， 1，

1， 1， 1， 1， 1， 1， 1， 1， 1， 2， 2， 2， 2， 2， 2， 2，

2， 3， 3， 3， 3， 3， 3， 3， 4， 4， 4， 4， 4， 5， 5， 5，

5， 6， 6， 6， 6， 7， 7， 7， 7， 8， 8， 8， 9， 9， 9， 10，

10， 10， 11， 11， 11， 12， 12， 13， 13， 13， 14， 14， 15， 15， 16， 16，

17， 17， 18， 18， 19， 19， 20， 20， 21， 21， 22， 22， 23， 24， 24， 25，

25， 26， 27， 27， 28， 29， 29， 30， 31， 32， 32， 33， 34， 35， 35， 36，

37， 38， 39， 39， 40， 41， 42， 43， 44， 45， 46， 47， 48， 49， 50， 50，

51， 52， 54， 55， 56， 57， 58， 59， 60， 61， 62， 63， 64， 66， 67， 68，

69， 70， 72， 73， 74， 75， 77， 78， 79， 81， 82， 83， 85， 86， 87， 89，

90， 92， 93， 95， 96， 98， 99，101，102，104，105，107，109，110，112，114，

115，117，119，120，122，124，126，127，129，131，133，135，137，138，140，142，

144，146，148，150，152，154，156，158，160，162，164，167，169，171，173，175，

177，180，182，184，186，189，191，193，196，198，200，203，205，208，210，213，

215，218，220，223，225，228，231，233，236，239，241，244，247，249，252，255 };

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/METODO SETUP

void setup（）

{

//Código： Dirección de la gravedad

neoring.begin（）;

neoring.setBrightness（200）;

Serial.begin（9600）;

Wire.begin（）;

Wire.beginTransmission（0x0A）; // address of the accelerometer

// range settings

Wire.write（0x22）; //register address

Wire.write（range）; //can be set at“0x00”“0x01”“0x02”“0x03”， refer to Datashhet on wiki

// low pass filter

Wire.write（0x20）; //register address

Wire.write（0x05）; //can be set at“0x05”“0x04”。..。..“0x01”“0x00”， refer to Datashhet on wiki

Wire.endTransmission（）;

//Codigo; Luces Arcoiris

// This is for Trinket 5V 16MHz， you can remove these three lines if you are not using a Trinket

#if defined （__AVR_ATtiny85__）

if （F_CPU == 16000000） clock_prescale_set（clock_div_1）;

#endif

// End of trinket special code

strip.begin（）;

strip.show（）; // Initialize all pixels to ’off‘

//Código Rueda de colores

// This is for Trinket 5V 16MHz， you can remove these three lines if you are not using a Trinket

#if defined （__AVR_ATtiny85__）

if （F_CPU == 16000000） clock_prescale_set（clock_div_1）;

#endif

// End of trinket special code

pixels.begin（）; // This initializes the NeoPixel library.

//Codigo Interrupcion

counter = 1;

//Codigo Colores varios

// This is for Trinket 5V 16MHz， you can remove these three lines if you are not using a Trinket

#if defined （__AVR_ATtiny85__）

if （F_CPU == 16000000） clock_prescale_set（clock_div_1）;

#endif

// End of trinket special code

strip.setBrightness（BRIGHTNESS）;

strip.begin（）;

strip.show（）; // Initialize all pixels to ’off‘

}

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/Bucle infinito

void loop（） {

//Caso 1： Juego de luces de la gravedad;

if（counter == 1）{

for（int i=0;i《100;i++）{

switch（range） //change the data dealing method based on the range u’ve set

{

case 0x00:divi=16; break;

case 0x01:divi=8; break;

case 0x02:divi=4; break;

case 0x03:divi=2; break;

default： Serial.println（“range setting is Wrong，range:from 0to 3.Please check！”）;while（1）;

}

AccelerometerInit（）;

delay（100）;

nx=x/2;

ny=y/2;

angle=atan（（ny/nx））*180/pi;

if（angle 》 0.0）{

if（nx《0.0）

angle+=180;

}

else{

if（ny 》 0.0）

angle+=180;

else

angle += 360;

}//end else

if（angle == 360.0）

angle = 0.0;

led = circularize（angle / （360 / NUMBER_OF_LEDS_ON_RING））;

// make led movement smooth

if（previousLed == led）{

// nothing to do

}

else if （counterClockwiseDistanceBetweenLeds（previousLed， led） 《= 8）

led = circularize（previousLed + 1）;

else

led = circularize（previousLed - 1）;

ledQueue.push（led）;

makeLightShow（）;

previousLed = led;

delay（25）;

}

counter = 2;

}//End if counter==1

//Caso 2： Codigo del juego de luces del arcoiris

else if（counter == 2）{

for（int j=0; j《5;j++）{

// Some example procedures showing how to display to the pixels：

colorWipe1（strip.Color（255， 0， 0）， 50）; // Red

colorWipe1（strip.Color（0， 255， 0）， 50）; // Green

colorWipe1（strip.Color（0， 0， 255）， 50）; // Blue

colorWipe1（strip.Color（0， 0， 0， 255）， 50）; // White RGBW

// Send a theater pixel chase in.。.

theaterChase（strip.Color（127， 127， 127）， 50）; // White

theaterChase（strip.Color（127， 0， 0）， 50）; // Red

theaterChase（strip.Color（0， 0， 127）， 50）; // Blue

rainbow（5）;

rainbowCycle（5）;

theaterChaseRainbow（5）;

}

counter = 3;

}//End if counter==2

//Caso 3： Luces Aleatorias

else if（counter == 3）{

for（int k=0;k《50;k++）{

// For a set of NeoPixels the first NeoPixel is 0， second is 1， all the way up to the count of pixels minus one.

int a=random（255）;

int b=random（255）;

int c=random（255）;

for（int i=0;i

// pixels.Color takes RGB values， from 0，0，0 up to 255，255，255

pixels.setPixelColor（i， pixels.Color（a，b，c））; // Moderately bright green color.

pixels.show（）; // This sends the updated pixel color to the hardware.

delay（delayval）; // Delay for a period of time （in milliseconds）。

}

a=random（255）;

b=random（255）;

c=random（255）;

for（int i=NUMPIXELS;i》0;i--）{

// pixels.Color takes RGB values， from 0，0，0 up to 255，255，255

pixels.setPixelColor（i， pixels.Color（a，b，c））; // Moderately bright green color.

pixels.show（）; // This sends the updated pixel color to the hardware.

delay（delayval）; // Delay for a period of time （in milliseconds）。

}

}

counter = 4;

}

else if（counter == 4）{

for（int g=0;g《=6;g++）{

// Some example procedures showing how to display to the pixels：

colorWipe（strip.Color（255， 0， 0）， 50）; // Red

colorWipe（strip.Color（0， 255， 0）， 50）; // Green

colorWipe（strip.Color（0， 0， 255）， 50）; // Blue

colorWipe（strip.Color（0， 0， 0， 255）， 50）; // White

whiteOverRainbow（20，75，5）;

pulseWhite（5）;

// fullWhite（）;

// delay（2000）;

rainbowFade2White（3，3，1）;

}

counter = 1;

}

}

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit（）

{

Wire.beginTransmission（0x0A）; // address of the accelerometer

// reset the accelerometer

Wire.write（0x04）; // X data

Wire.endTransmission（）;

Wire.requestFrom（0x0A，1）; // request 6 bytes from slave device #2

while（Wire.available（）） // slave may send less than requested

{

Version［0］ = Wire.read（）; // receive a byte as characte

}

x_data=（int8_t）Version［0］》》2;

Wire.beginTransmission（0x0A）; // address of the accelerometer

// reset the accelerometer

Wire.write（0x06）; // Y data

Wire.endTransmission（）;

Wire.requestFrom（0x0A，1）; // request 6 bytes from slave device #2

while（Wire.available（）） // slave may send less than requested

{

Version［1］ = Wire.read（）; // receive a byte as characte

}

y_data=（int8_t）Version［1］》》2;

Wire.beginTransmission（0x0A）; // address of the accelerometer

// reset the accelerometer

Wire.write（0x08）; // Z data

Wire.endTransmission（）;

Wire.requestFrom（0x0A，1）; // request 6 bytes from slave device #2

while（Wire.available（）） // slave may send less than requested

{

Version［2］ = Wire.read（）; // receive a byte as characte

}

z_data=（int8_t）Version［2］》》2;

x=（float）x_data/divi;

y=（float）y_data/divi;

z=（float）z_data/divi;

Serial.print（“X=”）;

Serial.print（x）; // print the character

Serial.print（“ ”）;

Serial.print（“Y=”）;

Serial.print（y）; // print the character

Serial.print（“ ”）;

Serial.print（“Z=”）; // print the character

Serial.println（z）;

}

int circularize（int pos）{

if（pos 》= NUMBER_OF_LEDS_ON_RING）

return（pos - NUMBER_OF_LEDS_ON_RING）;

else if（pos 《 0）

return（pos + NUMBER_OF_LEDS_ON_RING）;

else

return（pos）;

}

int distance;

int counterClockwiseDistanceBetweenLeds（int prevPos， int nextPos）{

distance = nextPos - prevPos;

if（distance 《 0）

distance += NUMBER_OF_LEDS_ON_RING;

return（distance）;

}

int ledPosition， currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10

int brightnessStep = 255/NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow（）{

for（int j = 0; j 《 NUMBER_OF_LEDS_ON_RING; j++）

neoring.setPixelColor（j， 0， 0， 0）;

currentQueueSize = ledQueue.count（）;

for（int k = 0; k 《 currentQueueSize; k++）{

ledPosition = ledQueue.pop（）;

neoring.setPixelColor（ledPosition， 0， （brightnessStep * k）， 0）;

if（（k == 0 && currentQueueSize 《 NUMBER_OF_LEDS_TO_SHINE） || k 》 0）

ledQueue.push（ledPosition）;

}

neoring.show（）;

}

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/Metodos del juego de luces del arcoiris

// Fill the dots one after the other with a color

void colorWipe（uint32_t c， uint8_t wait） {

for（uint16_t i=0; i

void rainbow（uint8_t wait） {

uint16_t i， j;

for（j=0; j《256; j++） {

for（i=0; i

// Slightly different， this makes the rainbow equally distributed throughout

void rainbowCycle（uint8_t wait） {

uint16_t i， j;

for（j=0; j《256*5; j++） { // 5 cycles of all colors on wheel

for（i=0; i《 strip.numPixels（）; i++） {

strip.setPixelColor（i， Wheel（（（i * 256 / strip.numPixels（）） + j） & 255））;

}

strip.show（）;

delay（wait）;

}

}

//Theatre-style crawling lights.

void theaterChase（uint32_t c， uint8_t wait） {

for （int j=0; j《10; j++） { //do 10 cycles of chasing

for （int q=0; q 《 3; q++） {

for （uint16_t i=0; i 《 strip.numPixels（）; i=i+3） {

strip.setPixelColor（i+q， c）; //turn every third pixel on

}

strip.show（）;

delay（wait）;

for （uint16_t i=0; i 《 strip.numPixels（）; i=i+3） {

strip.setPixelColor（i+q， 0）; //turn every third pixel off

}

}

}

}

//Theatre-style crawling lights with rainbow effect

void theaterChaseRainbow（uint8_t wait） {

for （int j=0; j 《 256; j++） { // cycle all 256 colors in the wheel

for （int q=0; q 《 3; q++） {

for （uint16_t i=0; i 《 strip.numPixels（）; i=i+3） {

strip.setPixelColor（i+q， Wheel（ （i+j） % 255））; //turn every third pixel on

}

strip.show（）;

delay（wait）;

for （uint16_t i=0; i 《 strip.numPixels（）; i=i+3） {

strip.setPixelColor（i+q， 0）; //turn every third pixel off

}

}

}

}

// Input a value 0 to 255 to get a color value.

// The colours are a transition r - g - b - back to r.

uint32_t Wheel（byte WheelPos） {

WheelPos = 255 - WheelPos;

if（WheelPos 《 85） {

return strip.Color（255 - WheelPos * 3， 0， WheelPos * 3）;

}

if（WheelPos 《 170） {

WheelPos -= 85;

return strip.Color（0， WheelPos * 3， 255 - WheelPos * 3）;

}

WheelPos -= 170;

return strip.Color（WheelPos * 3， 255 - WheelPos * 3， 0）;

}

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/Metodos Rueda de colores

// int elegirColor = random（0x000000，0xffffff）;//Se elige aleatoriamente entre toda la gama de colores comprendida entre 0x000000 y 0xFFFFFF

//CylonEyeColor=HtmlColor（elegirColor）;

//int elegirColor = random（1，7）;//Podemos elegir aleatoriamente entre los 7 colores que hay debajo0xf0ffff

// if（elegirColor == 1） CylonEyeColor=HtmlColor（0xff0000）;//Rojo

// if（elegirColor == 2） CylonEyeColor=HtmlColor（0x00ff00）;//Verde

// if（elegirColor == 3） CylonEyeColor=HtmlColor（0x0000ff）;//Azul

// if（elegirColor == 4） CylonEyeColor=HtmlColor（0xffff00）;//Amarillo

// if（elegirColor == 5） CylonEyeColor=HtmlColor（0x200020）;//Morado

// if（elegirColor == 6） CylonEyeColor=HtmlColor（0x00ffff）;//Azul Claro

// if（elegirColor == 7） CylonEyeColor=HtmlColor（0x100010）;//Rosa

//CylonEyeColor=HtmlColor（0x000000）;

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/Metodos luces varias

// Fill the dots one after the other with a color

void colorWipe1（uint32_t c， uint8_t wait） {

for（uint16_t i=0; i

void pulseWhite（uint8_t wait） {

for（int j = 0; j 《 256 ; j++）{

for（uint16_t i=0; i

for（int j = 255; j 》= 0 ; j--）{

for（uint16_t i=0; i

void rainbowFade2White（uint8_t wait， int rainbowLoops， int whiteLoops） {

float fadeMax = 100.0;

int fadeVal = 0;

uint32_t wheelVal;

int redVal， greenVal， blueVal;

for（int k = 0 ; k 《 rainbowLoops ; k ++）{

for（int j=0; j《256; j++） { // 5 cycles of all colors on wheel

for（int i=0; i《 strip.numPixels（）; i++） {

wheelVal = Wheel（（（i * 256 / strip.numPixels（）） + j） & 255）;

redVal = red（wheelVal） * float（fadeVal/fadeMax）;

greenVal = green（wheelVal） * float（fadeVal/fadeMax）;

blueVal = blue（wheelVal） * float（fadeVal/fadeMax）;

strip.setPixelColor（ i， strip.Color（ redVal， greenVal， blueVal ） ）;

}

//First loop， fade in！

if（k == 0 && fadeVal 《 fadeMax-1） {

fadeVal++;

}

//Last loop， fade out！

else if（k == rainbowLoops - 1 && j 》 255 - fadeMax ）{

fadeVal--;

}

strip.show（）;

delay（wait）;

}

}

delay（500）;

for（int k = 0 ; k 《 whiteLoops ; k ++）{

for（int j = 0; j 《 256 ; j++）{

for（uint16_t i=0; i 《 strip.numPixels（）; i++） {

strip.setPixelColor（i， strip.Color（0，0，0， neopix_gamma［j］ ） ）;

}

strip.show（）;

}

delay（2000）;

for（int j = 255; j 》= 0 ; j--）{

for（uint16_t i=0; i 《 strip.numPixels（）; i++） {

strip.setPixelColor（i， strip.Color（0，0，0， neopix_gamma［j］ ） ）;

}

strip.show（）;

}

}

delay（500）;

}

void whiteOverRainbow（uint8_t wait， uint8_t whiteSpeed， uint8_t whiteLength ） {

if（whiteLength 》= strip.numPixels（）） whiteLength = strip.numPixels（） - 1;

int head = whiteLength - 1;

int tail = 0;

int loops = 3;

int loopNum = 0;

static unsigned long lastTime = 0;

while（true）{

for（int j=0; j《256; j++） {

for（uint16_t i=0; i= tail && i 《= head） || （tail 》 head && i 》= tail） || （tail 》 head && i 《= head） ）{

strip.setPixelColor（i， strip.Color（0，0，0， 255 ） ）;

}

else{

strip.setPixelColor（i， Wheel（（（i * 256 / strip.numPixels（）） + j） & 255））;

}

}

if（millis（） - lastTime 》 whiteSpeed） {

head++;

tail++;

if（head == strip.numPixels（））{

loopNum++;

}

lastTime = millis（）;

}

if（loopNum == loops） return;

head%=strip.numPixels（）;

tail%=strip.numPixels（）;

strip.show（）;

delay（wait）;

}

}

}

void fullWhite（） {

for（uint16_t i=0; i

// Slightly different， this makes the rainbow equally distributed throughout

void rainbowCycle1（uint8_t wait） {

uint16_t i， j;

for（j=0; j《256 * 5; j++） { // 5 cycles of all colors on wheel

for（i=0; i《 strip.numPixels（）; i++） {

strip.setPixelColor（i， Wheel（（（i * 256 / strip.numPixels（）） + j） & 255））;

}

strip.show（）;

delay（wait）;

}

}

void rainbow1（uint8_t wait） {

uint16_t i， j;

for（j=0; j《256; j++） {

for（i=0; i

// Input a value 0 to 255 to get a color value.

// The colours are a transition r - g - b - back to r.

uint32_t Wheel1（byte WheelPos） {

WheelPos = 255 - WheelPos;

if（WheelPos 《 85） {

return strip.Color（255 - WheelPos * 3， 0， WheelPos * 3，0）;

}

if（WheelPos 《 170） {

WheelPos -= 85;

return strip.Color（0， WheelPos * 3， 255 - WheelPos * 3，0）;

}

WheelPos -= 170;

return strip.Color（WheelPos * 3， 255 - WheelPos * 3， 0，0）;

}

uint8_t red（uint32_t c） {

return （c 》》 16）;

}

uint8_t green（uint32_t c） {

return （c 》》 8）;

}

uint8_t blue（uint32_t c） {

return （c）;

}

步驟8：3D設計

首先，您必須調(diào)整硬件組件的大小以確保正確。如果它們與我們的相同，您可以使用我們借給您的相同文件。

兩種支持都是使用3D打印機設計的，它們也包括在內(nèi)：

ukelele_support_arduino_v0.stl：https：//www.tinkercad.com/things/1aAGZ1xFptA-ukel。 。. ukelele_support_WS2812_v0.stl：https：//www.tinkercad.com/things/1aAGZ1xFptA-ukel.。.

最后，燈光會像最后兩張照片一樣。

步驟9：安裝頸部

首先，我們將馬鞍放在頸部。螺絲需要固定的孔不在那里，所以我們必須制作它們，用螺旋鉆小心地標記它們應該去的地方，制作孔。

這同樣適用于用于將頸部固定在儀器主體上的螺釘?shù)目?。沒有必要這樣做，因為這種緊固沒有螺釘，但如果我們想這樣做，就沒有問題。

重要提示：在桅桿的起點和音叉的起點之間留出5mm的空間，因為在那個孔中將放置螺母。

我們將用膠水，按照圖中所示的方向。

最后，我們將在桅桿開頭的孔中引入4個針腳，每個針腳用2個短螺釘固定，如圖所示。

步驟10：安裝Birdge

通過粘合固定橋接兩個長螺釘位于車身中央位置。建議用鉛筆在身體上標記正確的位置。我們將采用圖像中標記的距離。

我們將在兩個組件的并集處應用膠水。我們在擰緊螺絲的幫助下仔細固定這兩個部件，直到接頭干燥。我們將用1.5mm鉆頭為木頭制作螺釘?shù)膬蓚€孔。用兩個長螺釘固定橋體。最后，我們將保護帽放在螺釘?shù)念^部。

步驟11：身體和頸部組裝

為了組裝這兩個部分，我們在身體的頭部有個洞，脖子上有兩個突出部分。我們可以用膠水或熱熔膠膠粘它們。為了獲得更大的固定效果，您可以將音叉末端的孔連接到身體上。

步驟12：放入尤克里里琴弦

最后我們必須放置字符串，以便我們的儀器完成。

以前我們會將銷的固定環(huán)插入穿過桅桿的突出部分中。為了放置琴弦，我們采用了套件附帶的4個琴弦。首先，您必須區(qū)分每個字符串，因為它們并非完全相同。你必須綁住每根弦的一端（兩個粗節(jié)用正常的結，兩個薄的用一個雙節(jié)）并將琴弦插入琴橋的插槽中。

然后我們將以下列方式放置字符串：

?第一個位置：G字符串（第二個最粗的字符串）。

?第二個位置：C字符串（粗字符串） ）。

?第三個位置：E字符串（第二個較細的字符串）。

?第四個位置：一個字符串（較細的字符串）。

將字符串穿入孔中提供的插頭。嘗試通過在銷上旋轉兩到三圈來固定每根繩子。在不施加過大力量的情況下拉緊琴弦并檢查琴弦和琴鞍之間的距離。

如果你對如何制作它有任何疑問，你可以在教程中解釋你如何正確地設置琴弦。

步驟13：測試

最后，我們要看看尤克里里琴是否有已正確組裝，使第一個音品上的理想距離為0.1毫米，而第十二個音符上的理想距離約為1.2毫米。

需要調(diào)整四弦琴弦。我推薦你這個應用程序：GuitarTuna