单片机教程网

电脑版
提示:原网页已由神马搜索转码, 内容由www.51hei.com提供.
查看:8827|回复:15

制作分享—arduino梦幻交互雪花2019 电路图+源代码

跳转到指定楼层
楼主
ID:487444发表于 2019-4-4 00:19|只看该作者|只看大图回帖奖励
雪花由30颗LED打造，分为17个独立的部分，由Arduino Nano控制。每组LED都可以用PWM调校，这样就可以创作出梦幻视觉效果。

首先打印一个漂亮而简单的雪花，记住要让它可以容纳Arduino Nano。

支撑结构也用于走线，由0.8mm黄铜棒与锡焊接而成。我总共使用了2米的黄铜棒。这是对你的耐心和技巧的一次考验。

首先，我通过弯曲一根黄铜棒并将两端焊接在一起来构建一个核心六边形。通过在六边形的顶部添加另外伸出6个黄铜棒，接地线完成，现在需要将LED的所有阴极引线焊接到其上以产生雪花图案。棘手的部分是添加贴片LED，不妨使用纸板和双面胶带制作的夹具。

接下来是在核心结构下加入Arduino Nano，在其间要留出足够的空间以满足3层黄铜棒接线，这将连接微控制器引脚到所有LED阳极引线。这同样需要极大的耐心。你不仅需要避免电线之间的短路，还要添加限流电阻并使其看起来不错。

叶片LED分别连接到最近的Arduino输出引脚。分支LED按两个分组并连接到PWM引脚。核心LED也按两个分组并连接到其余引脚。Arduino NANO只有18个输出引脚，我需要一个引脚用于触摸传感器，这只留下17个引脚，因此两对核心LED连接在一起形成一组4个。我使用220Ω电阻将每个引脚流过的电流限制在8mA左右。这意味着总共240mA，这对ATmega328芯片来说有点高，但它可以工作——安全最大值据说是200mA。
为了能够与雪花相互作用，我添加了另一个黄铜棒来制作电容式触摸传感器。

在焊接之前不要忘记随时检查所有二极管，如果开路或者反极性连接会很难更换它。


电路原理图如下：


Arduino源代码:
  1. #include "SoftPWM.h"
  2. #include< ADCTouchSensor.h>

  4. byte edgeLedPins[] = {13, A4, A5, 2, 8, 12};
  5. byte middleLedPins[] = {10, 6, 3, 5, 9, 11};
  6. byte innerLedPins[] = {A2, A3, A1, 4, 7, A1};

  8. ADCTouchSensor touchSensor = ADCTouchSensor(A0, 1);

  10. void setup() {
  11.   Serial.begin(115200);
  12.   SoftPWMBegin();
  13. }

  15. byte animation = 0;
  16. long touchAt = 0;

  18. void loop() {
  19.   switch (animation) {
  20.    case 0:
  21.      _fill(100);
  22.      break;
  23.    case 1:
  24.      shinyAnimation();
  25.      //fadingAnimation();
  26.      break;
  27.    case 2:
  28.      circleAnimation();
  29.      break;
  30.    case 3:
  31.      loopAnimation();
  32.      break;
  33.    case 4:
  34.      fireworkAnimation();
  35.      fireworkAnimation();
  36.      fireworkAnimation();
  37.      fireworkAnimation();
  38.      fireworkAnimation();
  39.      fireworkAnimation();
  40.      animation ++;
  41.      break;
  42.    case 5:
  43.      smileAnimation();
  44.      break;
  45.    default:
  46.      animation = 0;
  47.      break;
  48.   }
  49.   int touchValue = touchSensor.read();
  50.   if (touchAt + 2000< millis()&& touchValue > 1000) {
  51.    touchAt = millis(); // touch down, cold down timeout is 2s
  52.    animation ++;
  53.    _fill(0);
  54.   }
  55. }

  57. void fireworkAnimation() {
  58.   for (int i = 0; i< 4; i++) {
  59.    SoftPWMSet(innerLedPins[i], 100);
  60.    delay(100);
  61.   }
  62.   SoftPWMSet(innerLedPins[4], 100);
  63.   for (int i = 0; i< 6; i++) {
  64.    SoftPWMSet(middleLedPins[i], 255);
  65.   }
  66.   delay(50);
  67.   for (int i = 0; i< 6; i++) {
  68.    SoftPWMSet(innerLedPins[i], 0);
  69.    SoftPWMSet(edgeLedPins[i], 255);
  70.   }
  71.   delay(50);
  72.   for (int i = 0; i< 6; i++) {
  73.    SoftPWMSet(middleLedPins[i], 0);
  74.   }
  75.   delay(50);
  76.   _fill(0);
  77. }

  79. void smileAnimation() {
  80.   SoftPWMSet(innerLedPins[1], 100);
  81.   SoftPWMSet(innerLedPins[3], 100);
  82.   SoftPWMSet(middleLedPins[0], 255);
  83.   SoftPWMSet(middleLedPins[5], 255);
  84.   SoftPWMSet(edgeLedPins[2], 255);
  85.   SoftPWMSet(edgeLedPins[3], 255);
  86.   delay(2000);
  87.   SoftPWMSet(innerLedPins[1], 0);
  88.   SoftPWMSet(innerLedPins[3], 0);
  89.   delay(100);
  90.   SoftPWMSet(innerLedPins[1], 100);
  91.   SoftPWMSet(innerLedPins[3], 100);
  92.   delay(100);
  93.   SoftPWMSet(innerLedPins[1], 0);
  94.   SoftPWMSet(innerLedPins[3], 0);
  95.   delay(100);
  96. }

  98. byte circleState[] = {100, 55, 10};
  99. byte circleStateAnimation[] = {1, 1, 1};

  101. void circleAnimation() {
  102.   for (int i = 0; i< 3; i++) {
  103.    if (circleState[i] >= 100) {
  104.      circleStateAnimation[i] = -1; // dim
  105.    }
  106.    else if (circleState[i]< = 10) {
  107.      circleStateAnimation[i] = 1; // bright
  108.    }
  109.    circleState[i] += circleStateAnimation[i];
  110.   }
  111.   for (int i = 0; i< 6; i++) {
  112.    SoftPWMSet(innerLedPins[i], circleState[0]);
  113.    SoftPWMSet(middleLedPins[i], circleState[1]);
  114.    SoftPWMSet(edgeLedPins[i], circleState[2]);
  115.   }
  116.   delay(5);
  117. }

  119. byte waveState[] = {100, 55, 10, 10, 55, 100};
  120. byte waveStateAnimation[] = {1, 1, 1, -1, -1, -1};

  122. void waveAnimation() {
  123.   for (int i = 0; i< 6; i++) {
  124.    if (waveState[i] >= 100) {
  125.      waveStateAnimation[i] = -1; // dim
  126.    }
  127.    else if (waveState[i]< = 10) {
  128.      waveStateAnimation[i] = 1; // bright
  129.    }
  130.    waveState[i] += waveStateAnimation[i];
  131.   }
  132.   for (int i = 0; i< 6; i+=2) {
  133.    SoftPWMSet(innerLedPins[i], waveState[0]);
  134.    SoftPWMSet(middleLedPins[i], waveState[1]);
  135.    SoftPWMSet(edgeLedPins[i], waveState[2]);
  136.    SoftPWMSet(innerLedPins[i + 1], waveState[3]);
  137.    SoftPWMSet(middleLedPins[i + 1], waveState[4]);
  138.    SoftPWMSet(edgeLedPins[i + 1], waveState[5]);
  139.   }
  140.   delay(10);
  141. }

  143. byte loopCounter = 0;
  144. byte loopState = 150;

  146. void loopAnimation() {
  147.   SoftPWMSet(innerLedPins[loopCounter], loopState);
  148.   SoftPWMSet(middleLedPins[loopCounter], loopState);
  149.   SoftPWMSet(edgeLedPins[loopCounter], loopState);

  151.   loopCounter = _nextIndex(loopCounter, 1);
  152.   if (loopCounter == 0) {
  153.    loopState = (loopState == 150 ? 0 : 150);
  154.   }
  155.   delay(100);
  156. }

  158. byte slowOnCounter = 0;
  159. byte slowOnState = 150;

  161. void slowOnAnimation() {
  162.   byte randomLed = random(0, 18);
  163.   if (randomLed< 6) {
  164.    SoftPWMSet(innerLedPins[randomLed], slowOnState);
  165.   }
  166.   else if (randomLed< 12) {
  167.    SoftPWMSet(middleLedPins[randomLed - 6], slowOnState);
  168.   }
  169.   else {
  170.    SoftPWMSet(edgeLedPins[randomLed - 12], slowOnState);
  171.   }
  172.   slowOnCounter ++;
  173.   if (slowOnCounter >= 50) {
  174.    slowOnCounter = 0;
  175.    slowOnState = (slowOnState == 150 ? 0 : 150);
  176.   }
  177.   delay(50);
  178. }

  180. byte shinyState[] = {0, 100, 0, 100, 0, 100};
  181. byte shinyStateAnimation[] = {1, 1, 1, 1, 1, 1};
  182. byte shinyCounter = 0;

  184. void shinyAnimation() {
  185.   for (int i = 0; i< 6; i++) {
  186.    if (shinyState[i] >= 100) {
  187.      shinyStateAnimation[i] = -1; // dim
  188.    }
  189.    else if (shinyState[i]< = 0) {
  190.      shinyStateAnimation[i] = 1; // bright
  191.    }
  192.    shinyState[i] += shinyStateAnimation[i];
  193.    SoftPWMSet(edgeLedPins[i], shinyState[i]);
  194.   }
  195.   shinyCounter ++;
  196.   if (shinyCounter > 10) {
  197.    shinyCounter = 0;
  198.    for (byte r = random(1, 3); r > 0; r--) {
  199.      byte randomLed = random(0, 12);
  200.      if (randomLed< 6) {
  201.        SoftPWMSet(innerLedPins[random(0, 6)], 255);
  202.      }
  203.      else {
  204.        SoftPWMSet(middleLedPins[random(0, 6)], 255);
  205.      }
  206.    }
  207.   }
  208.   else {
  209.    for (int i = 0; i< 6; i++) {
  210.      SoftPWMSet(innerLedPins[i], 20);
  211.      SoftPWMSet(middleLedPins[i], 20);
  212.    }
  213.   }
  214.   delay(30);
  215. }

  217. byte fadingState[] = {0, 100, 0, 100, 0, 100};
  218. byte fadingStateAnimation[] = {1, 1, 1, 1, 1, 1};

  220. void fadingAnimation() {
  221.   for (int i = 0; i< 6; i++) {
  222.    if (fadingState[i] >= 100) {
  223.      fadingStateAnimation[i] = -1; // dim
  224.    }
  225.    else if (fadingState[i]< = 0) {
  226.      fadingStateAnimation[i] = 1; // bright
  227.    }
  228.    fadingState[i] += fadingStateAnimation[i];
  229.    SoftPWMSet(edgeLedPins[i], fadingState[i]);
  230.    SoftPWMSet(middleLedPins[_nextIndex(i, 1)], fadingState[i]);
  231.    SoftPWMSet(innerLedPins[i], 50);
  232.   }
  233.   delay(20);
  234. }

  236. void _fill(byte value) {
  237.   for (int i = 0; i< 6; i++) {
  238.    SoftPWMSet(edgeLedPins[i], value);
  239.    SoftPWMSet(middleLedPins[i], value);
  240.    SoftPWMSet(innerLedPins[i], value);
  241.   }
  242. }

  244. byte _prevIndex(short index, byte step) {
  245.   index -= step;
  246.   while (index< 0) {
  247.    index += 6;
  248.   }
  249.   return index;
  250. }

  252. byte _nextIndex(short index, byte step) {
  253.   index += step;
  254.   while (index > 5) {
  255.    index -= 6;
  256.   }
  257.   return index;
  258. }
复制代码


评分

黑币 +100
收起理由
+ 100
共享资料的黑币奖励！

查看全部评分

沙发
ID:491246发表于 2019-4-4 13:30|只看该作者
创意不错，有视频吗，看下实际效果
板凳
ID:102963发表于 2019-4-4 22:25|只看该作者
很不错的创意设计！！！
地板
ID:487444发表于 2019-4-6 16:49|只看该作者
PCB design for 梦幻雪花，你喜欢吗？视频上传不上来，感兴趣的可以留邮箱或者私信我我发给你，并且分享免费的PDF格式教程和ino格式源码哦。



5#
ID:507871发表于 2019-4-9 14:55|只看该作者
厉害啊，想法不错哦
7#
ID:259278发表于 2019-6-11 17:21|只看该作者
好看
9#
ID:282095发表于 2019-8-28 16:30|只看该作者
蛮不错创意 可以分享给我一份吗
10#
ID:313328发表于 2019-9-10 09:00|只看该作者
很有创意
11#
ID:559756发表于 2019-9-16 09:30|只看该作者
厉害厉害，大神无处不在
13#
ID:125719发表于 2019-9-29 10:28|只看该作者
这个是真的不错的哦，看起来就很漂亮的
15#
ID:98257发表于 2019-10-12 09:53|只看该作者
#include "SoftPWM.h" #include< ADCTouchSensor.h>这两个库在哪找？

手机版|小黑屋|51黑电子论坛|51黑电子论坛6群QQ管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网