简单有趣，基于 Attiny85 的Arduino DIY 超级马里奥的蘑菇徽章

鸣涧

简单有趣，基于 Attiny85 的Arduino DIY 超级马里奥的蘑菇徽章

MAKER:Arnov Sharma／译：鸣涧

今天给大家带来一期致敬经典的超级马里奥的徽章。可爱的蘑菇徽章，经典的红黄配色，立马把我们拉回到儿时的快乐的时光里（不小心暴露了年龄）。

这款可穿戴徽章由定制的 PCB 构成，采用 SOIC8 封装的 Attiny85 供电，添加了三个 WS2812B LED 灯可以使蘑菇徽章闪闪发光。你可以把它佩戴在身上也可以别在书包上。

制作过程很简单，喜欢的创客可以动手试试看！

组件清单

• 定制 PCB × 1
• Attiny85 × 1
• WS2812B LED 灯 × 3
• 1uf 0805 电容 × 1
• 胸针 × 1
• SMD 纽扣电池座 × 1
• CR2032 电池 × 1
• SOIC8 烧写夹 × 1
  

项目介绍

该徽章基于 Microchip 8 位的低功耗微控制器，同时结合了 8 KB ISP 闪存、512B EEPROM、512B SRAM和六条通用 I/O 线，由 Attiny85 供电。

它是一个功能强大的小型 MCU，可以缩小整个设置实现很多基于 Arduino 的项目。更多的数据资料可点击查看，https://www.microchip.com/en-us/product/ATtiny85。

我采用 CR2032 纽扣电池来供电，它可以为系统提供 3V 电压。其中，三个 WS2812B LED 灯，每个 LED 灯消耗 50mA，总共 150mA，CR2032 的容量为 210mAh，所以可以提供 1 小时以上的备份。

WS2812B LED 灯的数据资料可点击查看

https://cdn-shop.adafruit.com/datasheets/WS2812B.pdf。

PCB 板的创建过程

1、如图所示，我需要设计一个蘑菇形状的 PCB 板，将图形导入到 PCB Cad 软件。我选择黑白图像并将其作为 PCB 层导入。

2、如图所示，Attiny85 可以控制 Din Dout Config 并完成连接的三个 WS2812B LED 灯的所有工作。

第一个像素的 Dout 连接至第二个像素的 Din，第二个像素的 Dout 连接至第三个像素的 Din，然后再用第一个像素的 Din 提供一个信号来控制这三个像素。

每个LED 灯都有 1uf 的电容器，然后用一个开关连接到 Attiny85 的 D4。最后，将纽扣电池装入至电池仓供电。

3、设计 PCB 板

首先导入了蘑菇图像并将其用作 PCB 的轮廓，其中一些细节k可用于制作阻焊层。

所有组件都是 SMD，将它们放在背面，再将 LED 灯放置在圆形区域。在圆形区域我添加了一个阻焊层的开口，可以从顶部可以看到 LED 灯的余光。

这些 WS2812B LED 灯采取倒置的自定义封装，所以要将 LED 倒置焊接。

4、PCB 打样

在最后一次检查完电路板后，我将 Gerber 数据发送到 PCBWAY 以获取样品。我选择的材料是带有白色丝印的红色阻焊层。

我在两侧的阻焊层上预留了开口，这样就可以从顶部可以看到底部的LED 灯。

5、组装 PCB 板
组装 PCB 板主要有以下几个步骤：

a、锡膏点胶工艺
在每个元件焊盘上逐个添加焊膏。我使用的是带宽注射器的焊膏分配针，焊膏是由 63% 锡和 37% 铅组成的普通焊膏。

b、拾取和放置过程
使用镊子将每个组件放置在适当的位置，要小心地处理每一个元件。

c、热板回流
放置好元件后，将整个电路板放到我自制的热板回流焊板上进行焊接。完成后，请将其放置冷却。

d、安装 LED 灯
由于 PCB 板没有任何通孔组件，需要在焊盘上焊接电线，然后再将 LED 灯与它连接起来。焊接过程中尽量快一点，因为 LED 焊盘过热可能会引起外壳熔化。最后，完成三个 LED 灯的焊接。

安装 Attiny85

1、刷机过程中不能通过 USB 直接对 ATTINY85 进行编程，我采用 ISP 闪存的方法，通过 attiny85 的 SPI 引脚烧录引导加载程序，然后再烧录。

为了将 Attiny 与程序连接起来，我使用 SOIC8 烧写夹，直接将 Attiny 连接到该夹子上。

2、请在 Arduino IDE 中下载并安装 Attiny85 Core 文件，https://github.com/SpenceKonde/ATTinyCore 。

文件->首选项 PC 或者 Arduino->首选项 Mac，在 “Additional Boards Manager URLs” 中输入https://github.com/SpenceKonde/ATTinyCore 。

工具->主板->主板管理器，如果使用 1.6.6 版本，请关闭板子管理器并重新打开它。
选择”ATTinyCore by Spence Konde”，然后单击安装。

3、设置 AVR 芯片。AVR 芯片通常是空白的，它需要设置与 Arduino IDE 兼容性，所以需要编程 AVR 程序，例如 USBASP。这里有一个非常简单的方法，你可以使用 Arduino Uno 或 Nano 板制作自己的 AVR 编程器。

将 Arduino 板与 com 端口连接并选择以下 sketch：
Example->在 ArduinoISP 中将 sketch 上传至主板。进入工具菜单并在程序部分选择 Arduino 作为 ISP 选项。点亮 Attiny85 后，在 Board 部分选择 Attiny85。

编程过程会使用到 VCC、GND 和四个数据引脚。三个引脚分别连接到 MISO、MOSI 和 SCK 来实现目标，第四个引脚起到复位的作用。

4、用线将 Attiny85 与 Arduino 连接起来。
注意在将 ISP Sketch 上传到 Arduino 之后，需要在 Arduino 的 Reset 和 GND 引脚之间添加一个 10uf 的电容。

我没有使用 Arduino 和面包板来完成这项工作，而是使用我自制的用 Attiny 或 Atmega MCU 制作的 DIY Attiny Programmer。

具体详情可点击查看，https://www.instructables.com/Multiple-ATtiny8513A-Programmer/ 。

在以上接线配置中将主板连接到 Arduino 作为 ISP 设置。
选择正确的端口、正确的编程器（Arduino 作为 ISP），然后点击 Burn Bootloader。
等待几秒钟，你将完成烧录引导程序的消息。

打开要上传到这个 AttinyGo 的 Sketch，然后到 Sketch 菜单并选择上传程序。
最后 Sketch 会上传到 attiny85。

编码

编码是 Neopixel buttoncycler sketch，当按下连接到 attiny D4 的按钮时，就会改变 neopixels 的颜色和动画。

1. #include <Adafruit_NeoPixel.h>
   
2. 
   
3. #define BUTTON_PIN   4    // Digital IO pin connected to the button.  This will be
   
4.                           // driven with a pull-up resistor so the switch should
   
5.                           // pull the pin to ground momentarily.  On a high -> low
   
6.                           // transition the button press logic will execute.
   
7. 
   
8. #define PIXEL_PIN    0    // Digital IO pin connected to the NeoPixels.
   
9. 
   
10. #define PIXEL_COUNT 3
    
11. 
    
12. // Parameter 1 = number of pixels in strip,  neopixel stick has 8
    
13. // Parameter 2 = pin number (most are valid)
    
14. // Parameter 3 = pixel type flags, add together as needed:
    
15. //   NEO_RGB     Pixels are wired for RGB bitstream
    
16. //   NEO_GRB     Pixels are wired for GRB bitstream, correct for neopixel stick
    
17. //   NEO_KHZ400  400 KHz bitstream (e.g. FLORA pixels)
    
18. //   NEO_KHZ800  800 KHz bitstream (e.g. High Density LED strip), correct for neopixel stick
    
19. Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);
    
20. 
    
21. bool oldState = HIGH;
    
22. int showType = 0;
    
23. 
    
24. void setup() {
    
25.   pinMode(BUTTON_PIN, INPUT_PULLUP);
    
26.   strip.begin();
    
27.   strip.show(); // Initialize all pixels to 'off'
    
28. }
    
29. 
    
30. void loop() {
    
31.   // Get current button state.
    
32.   bool newState = digitalRead(BUTTON_PIN);
    
33. 
    
34.   // Check if state changed from high to low (button press).
    
35.   if (newState == LOW && oldState == HIGH) {
    
36.     // Short delay to debounce button.
    
37.     delay(20);
    
38.     // Check if button is still low after debounce.
    
39.     newState = digitalRead(BUTTON_PIN);
    
40.     if (newState == LOW) {
    
41.       showType++;
    
42.       if (showType > 9)
    
43.         showType=0;
    
44.       startShow(showType);
    
45.     }
    
46.   }
    
47. 
    
48.   // Set the last button state to the old state.
    
49.   oldState = newState;
    
50. }
    
51. 
    
52. void startShow(int i) {
    
53.   switch(i){
    
54.     case 0: colorWipe(strip.Color(0, 0, 0), 50);    // Black/off
    
55.             break;
    
56.     case 1: colorWipe(strip.Color(255, 0, 0), 50);  // Red
    
57.             break;
    
58.     case 2: colorWipe(strip.Color(0, 255, 0), 50);  // Green
    
59.             break;
    
60.     case 3: colorWipe(strip.Color(0, 0, 255), 50);  // Blue
    
61.             break;
    
62.     case 4: theaterChase(strip.Color(127, 127, 127), 50); // White
    
63.             break;
    
64.     case 5: theaterChase(strip.Color(127,   0,   0), 50); // Red
    
65.             break;
    
66.     case 6: theaterChase(strip.Color(  0,   0, 127), 50); // Blue
    
67.             break;
    
68.     case 7: rainbow(20);
    
69.             break;
    
70.     case 8: rainbowCycle(20);
    
71.             break;
    
72.     case 9: theaterChaseRainbow(50);
    
73.             break;
    
74.   }
    
75. }
    
76. 
    
77. // Fill the dots one after the other with a color
    
78. void colorWipe(uint32_t c, uint8_t wait) {
    
79.   for(uint16_t i=0; i<strip.numPixels(); i++) {
    
80.     strip.setPixelColor(i, c);
    
81.     strip.show();
    
82.     delay(wait);
    
83.   }
    
84. }
    
85. 
    
86. void rainbow(uint8_t wait) {
    
87.   uint16_t i, j;
    
88. 
    
89.   for(j=0; j<256; j++) {
    
90.     for(i=0; i<strip.numPixels(); i++) {
    
91.       strip.setPixelColor(i, Wheel((i+j) & 255));
    
92.     }
    
93.     strip.show();
    
94.     delay(wait);
    
95.   }
    
96. }
    
97. 
    
98. // Slightly different, this makes the rainbow equally distributed throughout
    
99. void rainbowCycle(uint8_t wait) {
    
100.   uint16_t i, j;
     
101. 
     
102.   for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
     
103.     for(i=0; i< strip.numPixels(); i++) {
     
104.       strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
     
105.     }
     
106.     strip.show();
     
107.     delay(wait);
     
108.   }
     
109. }
     
110. 
     
111. //Theatre-style crawling lights.
     
112. void theaterChase(uint32_t c, uint8_t wait) {
     
113.   for (int j=0; j<10; j++) {  //do 10 cycles of chasing
     
114.     for (int q=0; q < 3; q++) {
     
115.       for (int i=0; i < strip.numPixels(); i=i+3) {
     
116.         strip.setPixelColor(i+q, c);    //turn every third pixel on
     
117.       }
     
118.       strip.show();
     
119. 
     
120.       delay(wait);
     
121. 
     
122.       for (int i=0; i < strip.numPixels(); i=i+3) {
     
123.         strip.setPixelColor(i+q, 0);        //turn every third pixel off
     
124.       }
     
125.     }
     
126.   }
     
127. }
     
128. 
     
129. //Theatre-style crawling lights with rainbow effect
     
130. void theaterChaseRainbow(uint8_t wait) {
     
131.   for (int j=0; j < 256; j++) {     // cycle all 256 colors in the wheel
     
132.     for (int q=0; q < 3; q++) {
     
133.       for (int i=0; i < strip.numPixels(); i=i+3) {
     
134.         strip.setPixelColor(i+q, Wheel( (i+j) % 255));    //turn every third pixel on
     
135.       }
     
136.       strip.show();
     
137. 
     
138.       delay(wait);
     
139. 
     
140.       for (int i=0; i < strip.numPixels(); i=i+3) {
     
141.         strip.setPixelColor(i+q, 0);        //turn every third pixel off
     
142.       }
     
143.     }
     
144.   }
     
145. }
     
146. 
     
147. // Input a value 0 to 255 to get a color value.
     
148. // The colours are a transition r - g - b - back to r.
     
149. uint32_t Wheel(byte WheelPos) {
     
150.   WheelPos = 255 - WheelPos;
     
151.   if(WheelPos < 85) {
     
152.     return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
     
153.   }
     
154.   if(WheelPos < 170) {
     
155.     WheelPos -= 85;
     
156.     return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
     
157.   }
     
158.   WheelPos -= 170;
     
159.   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
     
160. }

复制代码

最后，安装好 CR2032 纽扣电池，这枚可爱的蘑菇徽章就可以闪光了。

via https://www.instructables.com/SHROOM-From-Super-Mario/