查看: 230|回复: 0

[未解决] 紅外線控制燈效 雙nano板溝通 delay改millis

[复制链接]

该用户从未签到

发表于 2020-9-26 01:26 | 显示全部楼层 |阅读模式
目前在寫用紅外線遙控器控制LED的6種燈效 分別是 開 呼吸燈1 呼吸燈2 流動燈效1 流動燈效2 關

目前發現 進入燈效循環後沒辦法隨時讀取紅外線的值切換燈效 上網查了下原因 應該是因為須等delay執行完畢後才能切換 所以需要改用millis()
上網看了一些millis()的教程 但是身為初學者的我還是看不太懂 不知道要怎麼融合進去 希望各位有經驗的大神們可以為我解解惑

主要控制nano板的程式
  1. #include <IRremote.h> //引入函數庫
  2. IRrecv irrecv(2); //將紅外線腳位設定為2
  3. decode_results results; //接收到的紅外線訊號值
  4. int back1 = 3 ;
  5. int back2 = 5 ;
  6. int back3 = 6 ;
  7. int back4 = 9 ;
  8. int back5 = 10 ;

  9. void setup() {
  10. pinMode( back1 , OUTPUT );
  11. pinMode( back2 , OUTPUT );
  12. pinMode( back3 , OUTPUT );
  13. pinMode( back4 , OUTPUT );
  14. pinMode( back5 , OUTPUT );
  15. Serial.begin(9600);
  16. irrecv.enableIRIn();  // 啟用紅外線接收
  17. Serial.println("Enabled IRin"); //印出啟動紅外線完成
  18. }

  19. void loop() {
  20.       if (irrecv.decode(&results)){ //如果接收到紅外線
  21.         long value =  results.value;
  22.         Serial.println(value);
  23.         irrecv.resume();
  24.       }
  25.       
  26.         long value = results.value ;
  27.         switch (value)
  28.         {
  29.            case 16726215:
  30.                            if (value != 16726215){
  31.                                 break;
  32.                                }
  33.                            on();
  34.                            break;
  35.            
  36.            case 16753245:
  37.                            if (value != 16753245){
  38.                                 break;
  39.                                }
  40.                            breathe1();
  41.                            break;
  42.            
  43.            case 16736925:
  44.                            if (value != 16736925){
  45.                                 break;
  46.                                }
  47.                            breathe2();
  48.                            break;
  49.            
  50.            case 16769565:               
  51.                            if (value != 16769565){
  52.                                 break;
  53.                                }
  54.                            flow();
  55.                            break;
  56.            
  57.            case 16720605:
  58.                            if (value != 16720605){
  59.                                 break;
  60.                                }
  61.                            attack();
  62.                            break;
  63.                            
  64.            case 16712445:
  65.                            if (value != 16712445){
  66.                                 break;
  67.                                }
  68.                            off();
  69.                            break;   

  70.            case 16761405:
  71.                          if (value != 16761405){
  72.                                 break;
  73.                                }
  74.                          breathe1();
  75.                          flow();
  76.                          flow();
  77.                          attack();
  78.                                        
  79.            
  80.         }
  81.           irrecv.resume(); // 讓接收器可以在接收
  82.            
  83.       
  84.       
  85.     delay(100);
  86.            }

  87. void on()
  88. {
  89.   Serial.write('U'); //先對 TX 送出字元 Y
  90.    while (!Serial.available()) {}  //檢查 RX 緩衝器, 直到有資料進來
  91.       if (Serial.read()=='A')   //若收到 A
  92.         {
  93.          digitalWrite(back1,HIGH);
  94.          digitalWrite(back2, HIGH);
  95.          digitalWrite(back3, HIGH);
  96.          digitalWrite(back4, HIGH);
  97.          digitalWrite(back5, HIGH);
  98.          
  99.         }  
  100. }


  101. void breathe1()
  102. {
  103.    
  104.             Serial.write('V'); //先對 TX 送出字元 Y
  105.             delay (10);
  106.             Serial.write('B'); //先對 TX 送出字元 Y
  107.             
  108.             while (!Serial.available()) {}
  109.             if (Serial.read()=='B')
  110.             {
  111.               Serial.write('C');
  112.               for(int i=0 ; i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  113.                   {            
  114.                     analogWrite(back1, i);       //類比寫入(腳位,數值0~255)              
  115.                     delay(2);                    //延遲5毫秒           
  116.                     analogWrite(back2, i);       //類比寫入(腳位,數值0~255)              
  117.                     delay(2);                    //延遲5毫秒           
  118.                     analogWrite(back3, i);       //類比寫入(腳位,數值0~255)              
  119.                     delay(2);                    //延遲5毫秒           
  120.                     analogWrite(back4, i);       //類比寫入(腳位,數值0~255)              
  121.                     delay(2);                    //延遲5毫秒           
  122.                     analogWrite(back5, i);       //類比寫入(腳位,數值0~255)              
  123.                     delay(2);                    //延遲5毫秒  
  124.                   }
  125.            }

  126.            while (!Serial.available()) {}
  127.             if (Serial.read()=='C')
  128.             {
  129.                for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  130.                   {
  131.                    analogWrite(back1, i);       //類比寫入(腳位,數值0~255)              
  132.                    delay(2);                    //延遲5毫秒           
  133.                    analogWrite(back2, i);       //類比寫入(腳位,數值0~255)              
  134.                    delay(2);                    //延遲5毫秒           
  135.                    analogWrite(back3, i);       //類比寫入(腳位,數值0~255)              
  136.                    delay(2);                    //延遲5毫秒           
  137.                    analogWrite(back4, i);       //類比寫入(腳位,數值0~255)              
  138.                    delay(2);                    //延遲5毫秒           
  139.                    analogWrite(back5, i);       //類比寫入(腳位,數值0~255)              
  140.                    delay(2);   
  141.                   }      
  142.             }      
  143. }




  144. void breathe2()
  145. {
  146.    
  147.     Serial.write('W'); //先對 TX 送出字元 Y
  148.     delay (10);
  149.     Serial.write('B'); //先對 TX 送出字元 Y
  150.             
  151.             while (!Serial.available()) {}
  152.             if (Serial.read()=='B')
  153.             {
  154.               Serial.write('C');
  155.               for(int i=0 ; i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  156.                   {            
  157.                     analogWrite(back1, i);       //延遲5毫秒           
  158.                     analogWrite(back2, i);      //延遲5毫秒           
  159.                     analogWrite(back3, i);       //延遲5毫秒           
  160.                     analogWrite(back4, i);       //延遲5毫秒           
  161.                     analogWrite(back5, i);       //延遲5毫秒  
  162.                   }
  163.            }

  164.            while (!Serial.available()) {}
  165.             if (Serial.read()=='C')
  166.             {
  167.                for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  168.                   {
  169.                    analogWrite(back1, i);       //延遲5毫秒           
  170.                    analogWrite(back2, i);      //延遲5毫秒           
  171.                    analogWrite(back3, i);        //延遲5毫秒           
  172.                    analogWrite(back4, i);       //延遲5毫秒           
  173.                    analogWrite(back5, i);
  174.                   }      
  175.             }      
  176. }



  177. void flow()
  178. {
  179.    
  180.   Serial.write('X'); //先對 TX 送出字元 Y
  181.     delay (10);
  182.              Serial.write('B'); //先對 TX 送出字元 Y
  183.             
  184.             while (!Serial.available()) {}
  185.             if (Serial.read()=='B')
  186.             {
  187.          for(int i=0 ; i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  188.          {
  189.           analogWrite(back1, i);       //類比寫入(腳位,數值0~255)              
  190.           delay(2);                    //延遲5毫秒           
  191.          }
  192.          for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  193.          {
  194.           analogWrite(back2, i);       //類比寫入(腳位,數值0~255)              
  195.           delay(2);                    //延遲5毫秒           
  196.          }
  197.          for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  198.          {
  199.           analogWrite(back3, i);       //類比寫入(腳位,數值0~255)              
  200.           delay(2);                    //延遲5毫秒           
  201.          }
  202.          for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  203.          {
  204.           analogWrite(back4, i);       //類比寫入(腳位,數值0~255)              
  205.           delay(2);                    //延遲5毫秒           
  206.          }
  207.          for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  208.          {
  209.           analogWrite(back5, i);       //類比寫入(腳位,數值0~255)              
  210.           delay(2);                    //延遲5毫秒           
  211.          }
  212.          Serial.write('C');
  213.             }

  214.            while (!Serial.available()) {}
  215.             if (Serial.read()=='C')
  216.             {
  217.               for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  218.            {
  219.             analogWrite(back1, i);      //類比寫入(腳位,數值0~255)              
  220.             delay(2);                   //延遲5毫秒   
  221.            }      
  222.            for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  223.            {
  224.             analogWrite(back2, i);      //類比寫入(腳位,數值0~255)              
  225.             delay(2);                   //延遲5毫秒   
  226.            }      
  227.            for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  228.            {
  229.             analogWrite(back3, i);      //類比寫入(腳位,數值0~255)              
  230.             delay(2);                   //延遲5毫秒   
  231.            }      
  232.            for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  233.            {
  234.             analogWrite(back4, i);      //類比寫入(腳位,數值0~255)              
  235.             delay(2);                   //延遲5毫秒   
  236.            }      
  237.            for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  238.            {
  239.             analogWrite(back5, i);      //類比寫入(腳位,數值0~255)              
  240.             delay(2);                   //延遲5毫秒   
  241.            }      
  242.            Serial.write('D');
  243.             
  244.             
  245.            }
  246. }


  247. void attack()
  248. {
  249.   
  250.               Serial.write('Y'); //先對 TX 送出字元 Y
  251.     delay (10);
  252.               Serial.write('B'); //先對 TX 送出字元 Y
  253.             
  254.             while (!Serial.available()) {}
  255.             if (Serial.read()=='B')
  256.             {
  257.          for(int i=0 ; i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  258.          {
  259.           analogWrite(back5, i);       //類比寫入(腳位,數值0~255)              
  260.           delay(5);                    //延遲5毫秒           
  261.          }
  262.          for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  263.          {
  264.           analogWrite(back4, i);       //類比寫入(腳位,數值0~255)              
  265.           delay(5);                    //延遲5毫秒           
  266.          }
  267.          for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  268.          {
  269.           analogWrite(back3, i);       //類比寫入(腳位,數值0~255)              
  270.           delay(5);                    //延遲5毫秒           
  271.          }
  272.          for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  273.          {
  274.           analogWrite(back2, i);       //類比寫入(腳位,數值0~255)              
  275.           delay(5);                    //延遲5毫秒           
  276.          }
  277.          for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  278.          {
  279.           analogWrite(back1, i);       //類比寫入(腳位,數值0~255)              
  280.           delay(5);                    //延遲5毫秒           
  281.          }
  282.          Serial.write('C');
  283.             }

  284.            while (!Serial.available()) {}
  285.             if (Serial.read()=='C')
  286.             {
  287.              Serial.write('D');
  288.            for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  289.            {
  290.             analogWrite(back1, i);      //類比寫入(腳位,數值0~255)              
  291.             delay(5);                   //延遲5毫秒   
  292.             analogWrite(back2, i);      //類比寫入(腳位,數值0~255)              
  293.             delay(5);                   //延遲5毫秒   
  294.             analogWrite(back3, i);      //類比寫入(腳位,數值0~255)              
  295.             delay(5);                   //延遲5毫秒   
  296.             analogWrite(back4, i);      //類比寫入(腳位,數值0~255)              
  297.             delay(5);                   //延遲5毫秒   
  298.             analogWrite(back5, i);      //類比寫入(腳位,數值0~255)              
  299.             delay(5);                   //延遲5毫秒   
  300.            }      
  301. }
  302. }


  303. void off()
  304. {
  305.   Serial.write('Z'); //先對 TX 送出字元 Y
  306.    while (!Serial.available()) {}  //檢查 RX 緩衝器, 直到有資料進來
  307.       if (Serial.read()=='A')   //若收到 A
  308.         {
  309.          digitalWrite(back1,LOW);
  310.          digitalWrite(back2, LOW);
  311.          digitalWrite(back3, LOW);
  312.          digitalWrite(back4, LOW);
  313.          digitalWrite(back5, LOW);
  314.          
  315.         }  
  316. }
复制代码
副nano板接收的程式
  1. int eye = 3 ;
  2. int mouth = 5 ;
  3. int tail_1 = 6 ;
  4. int tail_2 = 9 ;
  5. int tail_3 = 10 ;

  6. void setup() {
  7. pinMode(eye, OUTPUT);
  8. pinMode(mouth, OUTPUT);
  9. pinMode(tail_1, OUTPUT);
  10. pinMode(tail_2, OUTPUT);
  11. pinMode(tail_3, OUTPUT);
  12. Serial.begin(9600);
  13. }

  14. void loop()
  15. {
  16.   while (!Serial.available()) {}   //檢查 RX 緩衝區, 直到有資料進來
  17.   int Num = Serial.read();
  18.        if (Num=='U')
  19.        {
  20.        on();
  21.        }
  22.   else if (Num=='V')
  23.        {
  24.        breathe1();
  25.        }
  26.   else if (Num=='W')
  27.        {
  28.        breathe2();
  29.        }
  30.   else if (Num=='X')
  31.        {
  32.        flow();
  33.        }
  34.   else if (Num=='Y')
  35.        {
  36.        attack();
  37.        }
  38.   else if (Num=='Z')
  39.        {
  40.        off();
  41.        }
  42. }

  43. void on()
  44. {
  45.   Serial.write('A'); //先對 TX 送出字元 Y
  46.   digitalWrite(eye, HIGH);
  47.   digitalWrite(mouth, HIGH);
  48.   digitalWrite(tail_1, HIGH);
  49.   digitalWrite(tail_2, HIGH);
  50.   digitalWrite(tail_3, HIGH);
  51. }

  52. void breathe1()
  53. {
  54.        while (!Serial.available()) {}  
  55.        if (Serial.read()=='B')
  56.        {
  57.         Serial.write('B'); //延遲5毫秒
  58.         for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  59.          {
  60.          
  61.           analogWrite(eye, i);
  62.           delay(2);
  63.           analogWrite(mouth,i);
  64.           delay(2);
  65.           analogWrite(tail_1, i);       //類比寫入(腳位,數值0~255)              
  66.           delay(2);                    //延遲5毫秒           
  67.           analogWrite(tail_2, i);       //類比寫入(腳位,數值0~255)              
  68.           delay(2);                   //延遲5毫秒           
  69.           analogWrite(tail_3, i);       //類比寫入(腳位,數值0~255)              
  70.           delay(2);
  71.                      
  72.          }
  73.          
  74.        }

  75. while (!Serial.available()) {}  
  76.        if (Serial.read()=='C')
  77.        {
  78.         Serial.write('C');
  79.        for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  80.              {
  81.               
  82.           analogWrite(eye, i);
  83.           delay(2);
  84.           analogWrite(mouth,i);
  85.           delay(2);
  86.           analogWrite(tail_1, i);       //類比寫入(腳位,數值0~255)              
  87.           delay(2);                    //延遲5毫秒           
  88.           analogWrite(tail_2, i);       //類比寫入(腳位,數值0~255)              
  89.           delay(2);                   //延遲5毫秒           
  90.           analogWrite(tail_3, i);       //類比寫入(腳位,數值0~255)              
  91.           delay(2);   
  92.          
  93.              }
  94.          
  95.               
  96. }
  97. }

  98. void breathe2()
  99.       {
  100.              while (!Serial.available()) {}  
  101.        if (Serial.read()=='B')
  102.        {
  103.         Serial.write('B'); //延遲5毫秒
  104.         for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  105.          {
  106.          
  107.           analogWrite(eye, i);
  108.           analogWrite(mouth,i);
  109.           analogWrite(tail_1, i);      //延遲5毫秒           
  110.           analogWrite(tail_2, i);    //延遲5毫秒           
  111.           analogWrite(tail_3, i);
  112.                      
  113.          }
  114.          
  115.        }

  116. while (!Serial.available()) {}  
  117.        if (Serial.read()=='C')
  118.        {
  119.         Serial.write('C');
  120.        for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  121.              {
  122.               
  123.           analogWrite(eye, i);
  124.           analogWrite(mouth,i);
  125.           analogWrite(tail_1, i);      //延遲5毫秒           
  126.           analogWrite(tail_2, i);     //延遲5毫秒           
  127.           analogWrite(tail_3, i);
  128.          
  129.              }
  130.          
  131.               
  132. }
  133.         }
  134. void flow()           
  135.        {
  136.         while (!Serial.available()) {}   //檢查 RX 緩衝區, 直到有資料進來
  137.      if (Serial.read()=='B')
  138.        {
  139.          analogWrite(eye, 255);
  140.          analogWrite(mouth,255);         
  141.          delay(1000);
  142.          Serial.write('B');
  143.       }
  144.      while (!Serial.available()) {}  
  145.        if (Serial.read()=='C')
  146.        {
  147.         for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  148.          {
  149.           analogWrite(tail_1, i);       //類比寫入(腳位,數值0~255)              
  150.           delay(2);                    //延遲5毫秒           
  151.          }
  152.          for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  153.          {
  154.           analogWrite(tail_2, i);       //類比寫入(腳位,數值0~255)              
  155.           delay(2);                    //延遲5毫秒           
  156.          }
  157.          for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  158.          {
  159.           analogWrite(tail_3, i);       //類比寫入(腳位,數值0~255)              
  160.           delay(2);                    //延遲5毫秒           
  161.          }
  162.          Serial.write('C');
  163.        }

  164. while (!Serial.available()) {}  
  165.        if (Serial.read()=='D')
  166.        {
  167.        for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  168.              {
  169.               analogWrite(tail_1, i);      //類比寫入(腳位,數值0~255)              
  170.               delay(2);                   //延遲5毫秒   
  171.               }      
  172.        for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  173.              {
  174.               analogWrite(tail_2, i);      //類比寫入(腳位,數值0~255)              
  175.               delay(2);                   //延遲5毫秒   
  176.               }   
  177.        for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  178.              {
  179.               analogWrite(tail_3, i);      //類比寫入(腳位,數值0~255)              
  180.               delay(2);                   //延遲5毫秒   
  181.               }   
  182. }
  183. }

  184. void attack()
  185. {
  186.   while (!Serial.available()) {}  
  187.        if (Serial.read()=='B')
  188.        {
  189.          analogWrite(eye, 50);
  190.          delay(500);
  191.         for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  192.          {
  193.           analogWrite(tail_3, i);       //類比寫入(腳位,數值0~255)              
  194.           delay(5);                    //延遲5毫秒           
  195.          }
  196.          for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  197.          {
  198.           analogWrite(tail_2, i);       //類比寫入(腳位,數值0~255)              
  199.           delay(5);                    //延遲5毫秒           
  200.          }
  201.          for(int i=0;i<255;i++)       //設定i的起始值為1若是小於255,i就加1
  202.          {
  203.           analogWrite(tail_1, i);       //類比寫入(腳位,數值0~255)              
  204.           delay(5);                    //延遲5毫秒           
  205.          }
  206.          Serial.write('B');
  207.        }

  208.   while (!Serial.available()) {}   //檢查 RX 緩衝區, 直到有資料進來
  209.      if (Serial.read()=='C')
  210.        {
  211.           analogWrite(eye, 255);       //類比寫入(腳位,數值0~255)              
  212.           analogWrite(mouth,255);         
  213.          delay(5);
  214.          }
  215.          Serial.write('C');
  216.       

  217. while (!Serial.available()) {}  
  218.        if (Serial.read()=='D')
  219.        {
  220.        for(int i=255; i>=0;i--)       //設定i的起始值為255若是大於等於0,i就減1
  221.              {
  222.               analogWrite(tail_1, i);      //類比寫入(腳位,數值0~255)              
  223.               delay(5);                   //延遲5毫秒   
  224.               analogWrite(tail_2, i);      //類比寫入(腳位,數值0~255)              
  225.               delay(5);                   //延遲5毫秒   
  226.               analogWrite(tail_3, i);      //類比寫入(腳位,數值0~255)              
  227.               delay(5);  
  228.               analogWrite(mouth,i);         
  229.               delay(5);
  230.               analogWrite(eye,i+50);         
  231.               delay(5);
  232.               }
  233. }
  234. }
  235.   
  236. void off()
  237. {
  238.   Serial.write('A'); //先對 TX 送出字元 Y
  239.   digitalWrite(eye, LOW);
  240.   digitalWrite(mouth, LOW);
  241.   digitalWrite(tail_1, LOW);
  242.   digitalWrite(tail_2, LOW);
  243.   digitalWrite(tail_3, LOW);
  244. }
  245.             
复制代码
網路上看到的millis呼吸燈範例
  1. int LED = 3 ;
  2. #define UP 0
  3. #define DOWN 1

  4. // constants for min and max PWM
  5. const int minPWM = 0;
  6. const int maxPWM = 255;

  7. // State Variable for Fade Direction
  8. byte fadeDirection = UP;

  9. // Global Fade Value
  10. // but be bigger than byte and signed, for rollover
  11. int fadeValue = 0;

  12. // How smooth to fade?
  13. byte fadeIncrement = 5;

  14. // millis() timing Variable, just for fading
  15. unsigned long previousFadeMillis;

  16. // How fast to increment?
  17. int fadeInterval = 10;

  18. void setup() {
  19.   // put pwmLED into known state (off)
  20.   analogWrite(LED, fadeValue);
  21. }

  22. void doTheFade(unsigned long thisMillis) {
  23.   // is it time to update yet?
  24.   // if not, nothing happens
  25.   if (thisMillis - previousFadeMillis >= fadeInterval) {
  26.     // yup, it's time!
  27.     if (fadeDirection == UP) {
  28.       fadeValue = fadeValue + fadeIncrement;  
  29.       if (fadeValue >= maxPWM) {
  30.         // At max, limit and change direction
  31.         fadeValue = maxPWM;
  32.         fadeDirection = DOWN;
  33.       }
  34.     } else {
  35.       //if we aren't going up, we're going down
  36.       fadeValue = fadeValue - fadeIncrement;
  37.       if (fadeValue <= minPWM) {
  38.         // At min, limit and change direction
  39.         fadeValue = minPWM;
  40.         fadeDirection = UP;
  41.       }
  42.     }
  43.     // Only need to update when it changes
  44.     analogWrite(LED, fadeValue);


  45.     // reset millis for the next iteration (fade timer only)
  46.     previousFadeMillis = thisMillis;
  47.   }
  48. }

  49. void loop() {
  50.   // get the current time, for this time around loop
  51.   // all millis() timer checks will use this time stam
  52.   unsigned long currentMillis = millis();
  53.   Serial.write('B');  
  54.   doTheFade(currentMillis);

  55. }
复制代码
網路上看到的millis流動燈效範例  (此範例是HIGH,LOW模式的流動燈效 我希望的是analogWrite(LED,0~255) 呼吸式的流動燈效)
  1. const byte LEDpin[] = { 3,5 , 6 , 9, 10}; // <--- put your led pin sequence;
  2. const byte numberOfLED = sizeof ( LEDpin ) / sizeof ( LEDpin[0] );

  3. unsigned long timeNow = 0;
  4. unsigned long timePrev = 0;
  5. const unsigned long regularInterval = 300;
  6. const unsigned long pause = 1000;
  7. unsigned long interval = regularInterval;

  8. byte counter = 0;

  9. void setup ()
  10. {
  11.   for ( byte i = 0; i < numberOfLED; i++ )
  12.   {
  13.     pinMode (LEDpin[i] , OUTPUT);
  14.     digitalWrite ( LEDpin[i], LOW);
  15.   }
  16.   timePrev = millis();
  17. }

  18. void loop()
  19. {
  20.   timeNow = millis();
  21.   if ( timeNow - timePrev >= interval )
  22.   {
  23.     timePrev = timeNow;
  24.     if ( counter < numberOfLED )
  25.     {
  26.       digitalWrite ( LEDpin[counter], HIGH);
  27.     }
  28.     counter++;
  29.     if ( counter == numberOfLED ) interval = pause;
  30.     else interval = regularInterval;
  31.     if ( counter > numberOfLED )
  32.     {
  33.       counter = 0;
  34.       for ( byte i = 0; i < numberOfLED; i++ )
  35.       {
  36.         digitalWrite ( LEDpin[i], LOW);
  37.       }
  38.     }
  39.   }
  40. }
复制代码


您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

热门推荐

求助更快的Ping查看IP是否在线速度
求助更快的Ping查看IP是否
本人小白刚刚玩ESP8266-01S一个星期,想做一个远程开关电脑,目前在解决状态反馈遇到一
OLED 128*64自制可达10000000个选项的菜单(已更新)
OLED 128*64自制可达10000
OLED 128*64自制可达10000000个选项的菜单 温馨提示: 建议占个楼再食用本帖子
红外门禁蜂鸣器一直响,什么原因,怎么解决啊
红外门禁蜂鸣器一直响,什
程序运行之后蜂鸣器一直响,红外感应没有感应到它也一直响,是程序出了问题,还是装置
freerots mqtt_print_limt 限制函数的疑问
freerots mqtt_print_limt
blinker_mqtt.c 函数中的 blinker_mqtt_print函数中有一部分发送限制函数如下 i
基于BLINKER的无线USB电压电流表
基于BLINKER的无线USB电压
一、方案概述 目前市场上的USB电压电流表很多,但是数据的测量精度和采样频率都是固定
Copyright   ©2015-2016  Arduino中文社区  Powered by©Discuz!   
快速回复 返回顶部 返回列表