• Witaj na Forum Arduino Polska! Zapraszamy do rejestracji!
  • Znajdziesz tutaj wiele informacji na temat hardware / software.
Witaj! Logowanie Rejestracja


Ocena wątku:
  • 0 głosów - średnia: 0
  • 1
  • 2
  • 3
  • 4
  • 5
Driver PWM Led zawiesza arduino
#1
Witam , posiadam ten driver http://allegro.pl/ShowItem2.php?item=586...ule_id=201, podłączony jest do 24v zasilania zew. -> zasila 6 diod 3W, - masa dodatkowo podłączona jest do gnd arduino, a wyjście pwm do pinu 9, niestety po chwili, i krótkim cyklu rozjaśniania arduino się zawiesza.

Czy powinien być jakiś opornik na linii pwm -> pin9 ? 

Korzystam z tego sketcha ->
Kod:
/********************************************************************************************
/  AQma LED Control - version 1.2.0
/  Copyright (c) 2015 Marcin Grunt
/  Wszelkie prawa do AQma LED Control są zastrzeżone przez autora: Marcina Grunta. 
/  Poniższy kod programu można używać i rozpowszechniać za darmo, pod warunkiem 
/  zachowania informacji o licencji i autorstwie. 
/  Poniższy kod udostępniony jest bez żadnej gwarancji, używasz go na własne ryzyko.
/  Autor nie ponosi odpowiedzialności za szkody, utratę zysków, lub jakiekolwiek
/  inne straty wynikłe w konsekwencji uzywania, lub niemożności użycia poniższego kodu.
/  
/  Pozdrawiam i życzę bezproblemowej pracy:
/                           Marcin Grunt, magu@magu.pl
*********************************************************************************************/

#include <Wire.h>
#include <Time.h>
#include <EEPROM.h>
#include <DS1307RTC.h>

////////////////////////////////////
/////////// Ustawienia  //////////// 
////////////////////////////////////
                                 ///    
boolean ON=true, OFF=false;      ///
                                 ///
boolean pwm1Invert = false;      ///
boolean pwm2Invert = false;      ///
boolean pwm3Invert = false;      ///
boolean pwm4Invert = false;      ///
boolean pwm5Invert = false;      ///
boolean pwm6Invert = false;      ///
byte pwm1Pin = 3;                ///
byte pwm2Pin = 5;                ///
byte pwm3Pin = 6;                ///
byte pwm4Pin = 9;                ///
byte pwm5Pin = 10;               ///
byte pwm6Pin = 11;               ///
                                 ///
int  pwmSilkySmootTimeSec = 30;  ///
                                 ///
////////////////////////////////////
////////////////////////////////////



tmElements_t tm;
long unsigned currentTimeSec;


// PWM - 1
 byte pwm1Status, pwm1HOn, pwm1MOn, pwm1SOn;
 byte pwm1HOff, pwm1MOff, pwm1SOff, pwm1Min, pwm1Max;
 byte pwm1Sr, pwm1Ss, pwm1KeepLight;

// PWM - 2
 byte pwm2Status, pwm2HOn, pwm2MOn, pwm2SOn;
 byte pwm2HOff, pwm2MOff, pwm2SOff, pwm2Min, pwm2Max;
 byte pwm2Sr, pwm2Ss, pwm2KeepLight;

// PWM - 3
 byte pwm3Status, pwm3HOn, pwm3MOn, pwm3SOn;
 byte pwm3HOff, pwm3MOff, pwm3SOff, pwm3Min, pwm3Max;
 byte pwm3Sr, pwm3Ss, pwm3KeepLight;

// PWM - 4
 byte pwm4Status, pwm4HOn, pwm4MOn, pwm4SOn;
 byte pwm4HOff, pwm4MOff, pwm4SOff, pwm4Min, pwm4Max;
 byte pwm4Sr, pwm4Ss, pwm4KeepLight;

// PWM - 5
 byte pwm5Status, pwm5HOn, pwm5MOn, pwm5SOn;
 byte pwm5HOff, pwm5MOff, pwm5SOff, pwm5Min, pwm5Max;
 byte pwm5Sr, pwm5Ss, pwm5KeepLight;

 // PWM - 6
 byte pwm6Status, pwm6HOn, pwm6MOn, pwm6SOn;
 byte pwm6HOff, pwm6MOff, pwm6SOff, pwm6Min, pwm6Max;
 byte pwm6Sr, pwm6Ss, pwm6KeepLight;

 boolean justTurnedOn = true;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// SETUP //////////////////////////////////////////////////////////////////////

void setup()
{
Serial.begin(9600); 
 
  
  
  pinMode(pwm1Pin,OUTPUT);    pinMode(pwm2Pin,OUTPUT);  
  pinMode(pwm3Pin, OUTPUT);   pinMode(pwm4Pin, OUTPUT);   
  pinMode(pwm5Pin, OUTPUT);   pinMode(pwm6Pin, OUTPUT);  
  
  
// Ustaw stany poczatkowe 
  digitalWrite(pwm1Pin,OFF);    digitalWrite(pwm2Pin,OFF);
  digitalWrite(pwm3Pin,OFF);    digitalWrite(pwm4Pin,OFF);
  digitalWrite(pwm5Pin,OFF);    digitalWrite(pwm6Pin,OFF);  

  eEpromRead();
// Pobierz czas
// RTC.read(tm);
    

////////////////////////////////////////////////////////////// END SETUP //////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// *************************************************************************************************************************************** ///
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////// LOOP ///////////////////////////////////////////////////////////////////////

void loop()
{  
   long unsigned currentMillis= millis();
   char cmdOutputArray[64];
   char cmdChar = 0;
   String cmd = "";

   if (RTC.read(tm)) 
   {
   currentTimeSec =  (long(tm.Hour)*3600) + (long(tm.Minute)*60) + long(tm.Second);
   }
    
// Serial

    while (Serial.available() > 0)
     {
       cmdChar = Serial.read();
       delay(5);
       cmd.concat(cmdChar);
     }
     
   
     if (cmd != "") {
         
         cmd.toCharArray(cmdOutputArray,64);

           if (commandAnalysis(cmdOutputArray)) 
           { 
              eEpromRead();
           } 
         
           else 
           { 
             Serial.print("666,Bledne dane\n"); 
           }
          
     }
     
     cmd = "";
      
     
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     
//////////////////////////////////////// SILNIK //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          silkySmoothPowerOn(pwmSilkySmootTimeSec,currentMillis);
 
          // PWM 1 - 6
          if (currentMillis%4 == 0 ) {pwm(pwm1Pin, pwm1Status, pwm1HOn, pwm1MOn, pwm1SOn, pwm1HOff, pwm1MOff, pwm1SOff, pwm1Min, pwm1Max, pwm1Sr, pwm1Ss, pwm1KeepLight, pwm1Invert); }
          if (currentMillis%5 == 0 ) {pwm(pwm2Pin, pwm2Status, pwm2HOn, pwm2MOn, pwm2SOn, pwm2HOff, pwm2MOff, pwm2SOff, pwm2Min, pwm2Max, pwm2Sr, pwm2Ss, pwm2KeepLight, pwm2Invert); }
          if (currentMillis%6 == 0 ) {pwm(pwm3Pin, pwm3Status, pwm3HOn, pwm3MOn, pwm3SOn, pwm3HOff, pwm3MOff, pwm3SOff, pwm3Min, pwm3Max, pwm3Sr, pwm3Ss, pwm3KeepLight, pwm3Invert); } 
          if (currentMillis%7 == 0 ) {pwm(pwm4Pin, pwm4Status, pwm4HOn, pwm4MOn, pwm4SOn, pwm4HOff, pwm4MOff, pwm4SOff, pwm4Min, pwm4Max, pwm4Sr, pwm4Ss, pwm4KeepLight, pwm4Invert); }
          if (currentMillis%8 == 0 ) {pwm(pwm5Pin, pwm5Status, pwm5HOn, pwm5MOn, pwm5SOn, pwm5HOff, pwm5MOff, pwm5SOff, pwm5Min, pwm5Max, pwm5Sr, pwm5Ss, pwm5KeepLight, pwm5Invert); }
          if (currentMillis%9 == 0 ) {pwm(pwm6Pin, pwm6Status, pwm6HOn, pwm6MOn, pwm6SOn, pwm6HOff, pwm6MOff, pwm6SOff, pwm6Min, pwm6Max, pwm6Sr, pwm6Ss, pwm6KeepLight, pwm6Invert); }



////////////////////////////////////////////////////////////// END LOOP////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////




///////////////////////////////////////////////////////////////////////////
/////                       eEpromRead                                ///// 
///////////////////////////////////////////////////////////////////////////

void eEpromRead() {
                  
             // PWM - 1
             //pwm1Pin = EEPROM.read(281); 
                pwm1Status = EEPROM.read(282); 
                pwm1HOn = EEPROM.read(283); pwm1MOn = EEPROM.read(284);
                pwm1SOn = EEPROM.read(285); pwm1HOff = EEPROM.read(286); 
                 pwm1MOff = EEPROM.read(287); pwm1SOff = EEPROM.read(288);
                pwm1Min = EEPROM.read(289); pwm1Max = EEPROM.read(290); 
                 pwm1Sr = EEPROM.read(291); pwm1Ss = EEPROM.read(292);      
                pwm1KeepLight = EEPROM.read(293);

              // PWM - 2
              //pwm2Pin = EEPROM.read(301); 
                pwm2Status = EEPROM.read(302); 
                pwm2HOn = EEPROM.read(303); pwm2MOn = EEPROM.read(304);
                pwm2SOn = EEPROM.read(305); pwm2HOff = EEPROM.read(306); 
                 pwm2MOff = EEPROM.read(307); pwm2SOff = EEPROM.read(308);
                pwm2Min = EEPROM.read(309); pwm2Max = EEPROM.read(310); 
                 pwm2Sr = EEPROM.read(311); pwm2Ss = EEPROM.read(312);      
                pwm2KeepLight = EEPROM.read(313);
                
              // PWM - 3
              //pwm3Pin = EEPROM.read(331); 
                pwm3Status = EEPROM.read(332); 
                pwm3HOn = EEPROM.read(333); pwm3MOn = EEPROM.read(334);
                pwm3SOn = EEPROM.read(335); pwm3HOff = EEPROM.read(336); 
                 pwm3MOff = EEPROM.read(337); pwm3SOff = EEPROM.read(338);
                pwm3Min = EEPROM.read(339); pwm3Max = EEPROM.read(340); 
                 pwm3Sr = EEPROM.read(341); pwm3Ss = EEPROM.read(342);      
                pwm3KeepLight = EEPROM.read(343);

              // PWM - 4
              //pwm4Pin = EEPROM.read(371); 
                pwm4Status = EEPROM.read(372); 
                pwm4HOn = EEPROM.read(373); pwm4MOn = EEPROM.read(374);
                pwm4SOn = EEPROM.read(375); pwm4HOff = EEPROM.read(376); 
                pwm4MOff = EEPROM.read(377); pwm4SOff = EEPROM.read(378);
                pwm4Min = EEPROM.read(379); pwm4Max = EEPROM.read(380); 
                pwm4Sr = EEPROM.read(381); pwm4Ss = EEPROM.read(382);      
                pwm4KeepLight = EEPROM.read(383);

              // PWM - 5
              //pwm5Pin = EEPROM.read(391); 
                pwm5Status = EEPROM.read(392); 
                pwm5HOn = EEPROM.read(393); pwm5MOn = EEPROM.read(394);
                pwm5SOn = EEPROM.read(395); pwm5HOff = EEPROM.read(396); 
                pwm5MOff = EEPROM.read(397); pwm5SOff = EEPROM.read(398);
                pwm5Min = EEPROM.read(399); pwm5Max = EEPROM.read(400); 
                pwm5Sr = EEPROM.read(401); pwm5Ss = EEPROM.read(402);      
                pwm5KeepLight = EEPROM.read(403);
         
              // PWM - 6
              //pwm6Pin = EEPROM.read(411); 
                pwm6Status = EEPROM.read(412); 
                pwm6HOn = EEPROM.read(413); pwm6MOn = EEPROM.read(414);
                pwm6SOn = EEPROM.read(415); pwm6HOff = EEPROM.read(416); 
                pwm6MOff = EEPROM.read(417); pwm6SOff = EEPROM.read(418);
                pwm6Min = EEPROM.read(419); pwm6Max = EEPROM.read(420); 
                pwm6Sr = EEPROM.read(421); pwm6Ss = EEPROM.read(422);      
                pwm6KeepLight = EEPROM.read(423);
}

////////////////////////////////////////////////////////////////////////////////////////
/////                   Silky Smooth Power On                                      /////
////////////////////////////////////////////////////////////////////////////////////////
void silkySmoothPowerOn(int silkySmoothTime, unsigned long currentMillis)
{
 static unsigned int silkySmoothCounter = 0;
 static unsigned long silkySmoothLastCounterTime = 0;
 silkySmoothTime = silkySmoothTime; 
  
  if (justTurnedOn && silkySmoothCounter <= silkySmoothTime) 
    {
    if ( currentMillis < 1000 ) { pwm1Max = 0; pwm2Max = 0; pwm3Max = 0; pwm4Max = 0; pwm5Max = 0; pwm6Max = 0; }
   
    if ( (currentMillis - silkySmoothLastCounterTime) >= 1000 ) 
       { 
        silkySmoothCounter++; 
        silkySmoothLastCounterTime = currentMillis; 
        pwm1Max = ((EEPROM.read(290) / silkySmoothTime)*silkySmoothCounter);
        pwm2Max = ((EEPROM.read(310) / silkySmoothTime)*silkySmoothCounter);
        pwm3Max = ((EEPROM.read(340) / silkySmoothTime)*silkySmoothCounter);
        pwm4Max = ((EEPROM.read(380) / silkySmoothTime)*silkySmoothCounter);
        pwm5Max = ((EEPROM.read(400) / silkySmoothTime)*silkySmoothCounter);
        pwm6Max = ((EEPROM.read(420) / silkySmoothTime)*silkySmoothCounter); 
       } 

        if ( silkySmoothCounter == silkySmoothTime) 
           {
            justTurnedOn = false;
            eEpromRead();
           }
    
    }
    
 }

////////////////////////////////////////////////////////////////////////////////////////
/////                               PWM Function                                   /////
////////////////////////////////////////////////////////////////////////////////////////

byte pwm(byte pwmPin, byte pwmStatus, byte pwmHOn, byte pwmMOn, byte pwmSOn, byte pwmHOff, byte pwmMOff, byte pwmSOff, byte pwmMin, byte pwmMax, byte pwmSr, byte pwmSs, byte pwmKeepLight, boolean pwmInvert)
{
  byte low=0, high=255;

  if (pwmInvert) { low = 255; high = 0;}
  if (!pwmInvert) { low = 0; high = 255;}
  
  if ( pwmStatus == 0 ) { analogWrite(pwmPin,map(0,0,255,low,high)); return map(0,0,255,low,high); }
  
  
  long pwmOn = (long(pwmHOn)*3600) + (long(pwmMOn)*60) + long(pwmSOn);
  long pwmOff  = (long(pwmHOff)*3600) + (long(pwmMOff)*60) + long(pwmSOff);
  
  boolean state = false;
    
  if (pwmOn < pwmOff) {         // Normalnie  
      if (currentTimeSec >= pwmOn && currentTimeSec < pwmOff) { state = true; }  
  }  
  
  if (pwmOn > pwmOff) {         // Zasuwaj dookola
      if (currentTimeSec >= pwmOn && currentTimeSec <= 86400) { state = true; }
      if (currentTimeSec >= 0 && currentTimeSec < pwmOff) { state = true; }
  }

  if (!state && !pwmKeepLight ) { analogWrite(pwmPin,map(0,0,255,low,high)); return map(0,0,255,low,high); } 
  if (!state && pwmKeepLight )  {   if (pwmMin > 1 && pwmMin <3) {pwmMin = 1;} analogWrite(pwmPin,map(pwmMin,0,255,low,high)); return map(pwmMin,0,255,low,high); } 
  
////////////////////////////////////
////  Swity 
///////////////////////////////////
   float jump;
   float sunriseLenght = pwmSr*60;
   long elapsed;
   long pwmSunriseStop = pwmOn + sunriseLenght;
   long pwm;
   if (sunriseLenght == 0 ) { sunriseLenght = 1;}
   jump = ((pwmMax-pwmMin)/sunriseLenght);
 
 if ( pwmSunriseStop < 86399 && currentTimeSec >= pwmOn &&  currentTimeSec <= pwmSunriseStop ) {         
    
   elapsed = sunriseLenght-(sunriseLenght-(currentTimeSec-pwmOn));
   pwm = pwmMin+(elapsed*jump);
   analogWrite(pwmPin,map(pwm,0,255,low,high));
   return map(pwm,0,255,low,high);           
  } 
  
   if (( pwmSunriseStop > 86399 && currentTimeSec >= pwmOn &&  currentTimeSec <= 86399 ) // przez zero
      || pwmSunriseStop > 86399 && currentTimeSec >= 0 && (currentTimeSec < (pwmSunriseStop - 86399)))
   {
    if (currentTimeSec>=pwmOn && currentTimeSec<=86399) 
     {
       elapsed = (sunriseLenght-(sunriseLenght-(currentTimeSec-pwmOn)));
     } 
    else
     {
      elapsed = sunriseLenght-(sunriseLenght -(86399-pwmOn+currentTimeSec));
     }
   
   pwm = pwmMin+(elapsed*jump);
   analogWrite(pwmPin,map(pwm,0,255,low,high));
   return map(pwm,0,255,low,high);
  }
 
 
 ///////////////////////
 ///// Zmierzchy ///////
 ///////////////////////
 float sunsetLenght = pwmSs*60;
 float sunsetStart;
 
  
 if ( (pwmOff - sunsetLenght) >= 0 )
 {
  sunsetStart = pwmOff - sunsetLenght;  
 }
 else
 {
  sunsetStart = 86400 + (pwmOff - sunsetLenght);
 }
 

   if (sunsetStart < pwmOff && sunsetStart >= 0 && currentTimeSec >= sunsetStart && currentTimeSec <= pwmOff) 
     { // Normalnie
       elapsed = (currentTimeSec - sunsetStart);
       if (sunsetLenght == 0 )  { sunsetLenght = 1; }
       jump = (pwmMax - pwmMin) / sunsetLenght;
       pwm = pwmMax - ( elapsed * jump );
       analogWrite(pwmPin,map(pwm,0,255,low,high));
       return map(pwm,0,255,low,high);
     } 
     
 
    if (sunsetStart > pwmOff && currentTimeSec >= sunsetStart && currentTimeSec <= 86400) 
    { 
       elapsed = (currentTimeSec - sunsetStart);
       if (sunsetLenght == 0 ) { sunsetLenght = 1;}
       jump = (pwmMax - pwmMin) / sunsetLenght;
       pwm = pwmMax - ( elapsed * jump );
       analogWrite(pwmPin,map(pwm,0,255,low,high));
       return map(pwm,0,255,low,high);
    }

    if (sunsetStart > pwmOff && currentTimeSec >= 0 && currentTimeSec < pwmOff) 
   {
       elapsed = (86400-sunsetStart)+currentTimeSec;
       if (sunsetLenght == 0 ) { sunsetLenght = 1;}
       jump = ( pwmMax - pwmMin) / sunsetLenght;
       pwm = pwmMax-(elapsed * jump);
       analogWrite(pwmPin,map(pwm,0,255,low,high));
       return map(pwm,0,255,low,high);
   }
   
 
 //// Jak sie nic nie zlapalo, to wypal oczy
   analogWrite(pwmPin,map(pwmMax,0,255,low,high));
   return map(pwmMax,0,255,low,high);

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

////////////////////////////////////////////////////////////////////////////////////////
/////                             Analysis                                         /////
////////////////////////////////////////////////////////////////////////////////////////

 boolean commandAnalysis(char cmdOutputArray[64]){

  unsigned int val[64];
  char *cmdVal;
  int i = 0;
  
  cmdVal = strtok(cmdOutputArray, ",");
  
      while (cmdVal) 
      {
       val[i++] = atoi(cmdVal);
       cmdVal = strtok(NULL, ",");
      }
 


 ///////////////////////////////////////////////////////////////////////////////////////
 /////                        PWM - 1, EPROM                                       ///// 
 ///////////////////////////////////////////////////////////////////////////////////////
  if (val[0] == 31) 
  { //      1          2         3            4        5          6          7         8        9          10        11       12         13
    byte ePwm1Pin, ePwm1Status, ePwm1HOn, ePwm1MOn, ePwm1SOn, ePwm1HOff, ePwm1MOff, ePwm1SOff, ePwm1Min, ePwm1Max, ePwm1Sr, ePwm1Ss, ePwm1KeepLight;
         
      if (val[1] >=0 && val[1] <= 99) { ePwm1Pin = val[1]; } else { return false;}             // ePwm1Pin -       1 
      if (val[2] >=0 && val[2] <= 1)  { ePwm1Status = val[2]; } else { return false;}          // ePwm1Status -    2
      if (val[3] >=0 && val[3] <= 23) { ePwm1HOn = val[3]; } else { return false;}             // ePwm1HOn -       3
      if (val[4] >=0 && val[4] <= 59) { ePwm1MOn = val[4]; } else { return false;}             // ePwm1MOn -       4
      if (val[5] >=0 && val[5] <= 59) { ePwm1SOn = val[5]; } else { return false;}             // ePwm1SOn -       5
      if (val[6] >=0 && val[6] <= 23) { ePwm1HOff = val[6]; } else { return false;}            // ePwm1HOff -      6
      if (val[7] >=0 && val[7] <= 59) { ePwm1MOff = val[7]; } else { return false;}            // ePwm1MOff -      7
      if (val[8] >=0 && val[8] <= 59) { ePwm1SOff = val[8]; } else { return false;}            // ePwm1SOff -      8
      if (val[9] >=0 && val[9] <= 255) { ePwm1Min = val[9]; } else { return false;}            // ePwm1Min -       9
      if (val[10] >=0 && val[10] <= 255) { ePwm1Max = val[10]; } else { return false;}         // ePwm1Max -       10
      if (val[11] >=0 && val[11] <= 255) { ePwm1Sr = val[11]; } else { return false;}          // ePwm1Sr -        11
      if (val[12] >=0 && val[12] <= 255) { ePwm1Ss = val[12]; } else { return false;}          // ePwm1Ss -        12
      if (val[13] >=0 && val[13] <= 1)   { ePwm1KeepLight = val[13]; } else { return false;}   // ePwm1KeepLight - 13
      
     EEPROM.write(281,ePwm1Pin); EEPROM.write(282,ePwm1Status); EEPROM.write(283,ePwm1HOn); EEPROM.write(284,ePwm1MOn);
     EEPROM.write(285,ePwm1SOn); EEPROM.write(286,ePwm1HOff); EEPROM.write(287,ePwm1MOff); EEPROM.write(288,ePwm1SOff);
     EEPROM.write(289,ePwm1Min); EEPROM.write(290,ePwm1Max); EEPROM.write(291,ePwm1Sr); EEPROM.write(292,ePwm1Ss);      
     EEPROM.write(293,ePwm1KeepLight); 
  }  


 ///////////////////////////////////////////////////////////////////////////////////////
 /////                        PWM - 2, EPROM                                       ///// 
 ///////////////////////////////////////////////////////////////////////////////////////
  if (val[0] == 32) 
  { //      1          2         3            4        5          6          7         8        9          10        11       12         13
    byte ePwm2Pin, ePwm2Status, ePwm2HOn, ePwm2MOn, ePwm2SOn, ePwm2HOff, ePwm2MOff, ePwm2SOff, ePwm2Min, ePwm2Max, ePwm2Sr, ePwm2Ss, ePwm2KeepLight;
      
      if (val[1] >=0 && val[1] <= 99) { ePwm2Pin = val[1]; } else { return false;}             // ePwm2Pin -       1 
      if (val[2] >=0 && val[2] <= 1)  { ePwm2Status = val[2]; } else { return false;}          // ePwm2Status -    2
      if (val[3] >=0 && val[3] <= 23) { ePwm2HOn = val[3]; } else { return false;}             // ePwm2HOn -       3
      if (val[4] >=0 && val[4] <= 59) { ePwm2MOn = val[4]; } else { return false;}             // ePwm2MOn -       4
      if (val[5] >=0 && val[5] <= 59) { ePwm2SOn = val[5]; } else { return false;}             // ePwm2SOn -       5
      if (val[6] >=0 && val[6] <= 23) { ePwm2HOff = val[6]; } else { return false;}            // ePwm2HOff -      6
      if (val[7] >=0 && val[7] <= 59) { ePwm2MOff = val[7]; } else { return false;}            // ePwm2MOff -      7
      if (val[8] >=0 && val[8] <= 59) { ePwm2SOff = val[8]; } else { return false;}            // ePwm2SOff -      8
      if (val[9] >=0 && val[9] <= 255) { ePwm2Min = val[9]; } else { return false;}            // ePwm2Min -       9
      if (val[10] >=0 && val[10] <= 255) { ePwm2Max = val[10]; } else { return false;}         // ePwm2Max -       10
      if (val[11] >=0 && val[11] <= 255) { ePwm2Sr = val[11]; } else { return false;}          // ePwm2Sr -        11
      if (val[12] >=0 && val[12] <= 255) { ePwm2Ss = val[12]; } else { return false;}          // ePwm2Ss -        12
      if (val[13] >=0 && val[13] <= 1)   { ePwm2KeepLight = val[13]; } else { return false;}   // ePwm2KeepLight - 13
      
     EEPROM.write(301,ePwm2Pin); EEPROM.write(302,ePwm2Status); EEPROM.write(303,ePwm2HOn); EEPROM.write(304,ePwm2MOn);
     EEPROM.write(305,ePwm2SOn); EEPROM.write(306,ePwm2HOff); EEPROM.write(307,ePwm2MOff); EEPROM.write(308,ePwm2SOff);
     EEPROM.write(309,ePwm2Min); EEPROM.write(310,ePwm2Max); EEPROM.write(311,ePwm2Sr); EEPROM.write(312,ePwm2Ss);      
     EEPROM.write(313,ePwm2KeepLight); 
  }  
 
 ///////////////////////////////////////////////////////////////////////////////////////
 /////                        PWM - 3, EPROM                                       ///// 
 ///////////////////////////////////////////////////////////////////////////////////////
  if (val[0] == 33) 
  { //      1          2         3            4        5          6          7         8        9          10        11       12         13
    byte ePwm3Pin, ePwm3Status, ePwm3HOn, ePwm3MOn, ePwm3SOn, ePwm3HOff, ePwm3MOff, ePwm3SOff, ePwm3Min, ePwm3Max, ePwm3Sr, ePwm3Ss, ePwm3KeepLight;
      
      if (val[1] >=0 && val[1] <= 99) { ePwm3Pin = val[1]; } else { return false;}             // ePwm3Pin -       1 
      if (val[2] >=0 && val[2] <= 1)  { ePwm3Status = val[2]; } else { return false;}          // ePwm3Status -    2
      if (val[3] >=0 && val[3] <= 23) { ePwm3HOn = val[3]; } else { return false;}             // ePwm3HOn -       3
      if (val[4] >=0 && val[4] <= 59) { ePwm3MOn = val[4]; } else { return false;}             // ePwm3MOn -       4
      if (val[5] >=0 && val[5] <= 59) { ePwm3SOn = val[5]; } else { return false;}             // ePwm3SOn -       5
      if (val[6] >=0 && val[6] <= 23) { ePwm3HOff = val[6]; } else { return false;}            // ePwm3HOff -      6
      if (val[7] >=0 && val[7] <= 59) { ePwm3MOff = val[7]; } else { return false;}            // ePwm3MOff -      7
      if (val[8] >=0 && val[8] <= 59) { ePwm3SOff = val[8]; } else { return false;}            // ePwm3SOff -      8
      if (val[9] >=0 && val[9] <= 255) { ePwm3Min = val[9]; } else { return false;}            // ePwm3Min -       9
      if (val[10] >=0 && val[10] <= 255) { ePwm3Max = val[10]; } else { return false;}         // ePwm3Max -       10
      if (val[11] >=0 && val[11] <= 255) { ePwm3Sr = val[11]; } else { return false;}          // ePwm3Sr -        11
      if (val[12] >=0 && val[12] <= 255) { ePwm3Ss = val[12]; } else { return false;}          // ePwm3Ss -        12
      if (val[13] >=0 && val[13] <= 1)   { ePwm3KeepLight = val[13]; } else { return false;}   // ePwm3KeepLight - 13

      
     EEPROM.write(331,ePwm3Pin); EEPROM.write(332,ePwm3Status); EEPROM.write(333,ePwm3HOn); EEPROM.write(334,ePwm3MOn);
     EEPROM.write(335,ePwm3SOn); EEPROM.write(336,ePwm3HOff); EEPROM.write(337,ePwm3MOff); EEPROM.write(338,ePwm3SOff);
     EEPROM.write(339,ePwm3Min); EEPROM.write(340,ePwm3Max); EEPROM.write(341,ePwm3Sr); EEPROM.write(342,ePwm3Ss);      
     EEPROM.write(343,ePwm3KeepLight); 
  }  

  ///////////////////////////////////////////////////////////////////////////////////////
 /////                        PWM - 4, EPROM                                       ///// 
 ///////////////////////////////////////////////////////////////////////////////////////
  if (val[0] == 90) 
  { //      1          2         3            4        5          6          7         8        9          10        11       12         13
    byte ePwm4Pin, ePwm4Status, ePwm4HOn, ePwm4MOn, ePwm4SOn, ePwm4HOff, ePwm4MOff, ePwm4SOff, ePwm4Min, ePwm4Max, ePwm4Sr, ePwm4Ss, ePwm4KeepLight;
      
      if (val[1] >=0 && val[1] <= 99) { ePwm4Pin = val[1]; } else { return false;}             // ePwm4Pin -       1 
      if (val[2] >=0 && val[2] <= 1)  { ePwm4Status = val[2]; } else { return false;}          // ePwm4Status -    2
      if (val[3] >=0 && val[3] <= 23) { ePwm4HOn = val[3]; } else { return false;}             // ePwm4HOn -       3
      if (val[4] >=0 && val[4] <= 59) { ePwm4MOn = val[4]; } else { return false;}             // ePwm4MOn -       4
      if (val[5] >=0 && val[5] <= 59) { ePwm4SOn = val[5]; } else { return false;}             // ePwm4SOn -       5
      if (val[6] >=0 && val[6] <= 23) { ePwm4HOff = val[6]; } else { return false;}            // ePwm4HOff -      6
      if (val[7] >=0 && val[7] <= 59) { ePwm4MOff = val[7]; } else { return false;}            // ePwm4MOff -      7
      if (val[8] >=0 && val[8] <= 59) { ePwm4SOff = val[8]; } else { return false;}            // ePwm4SOff -      8
      if (val[9] >=0 && val[9] <= 255) { ePwm4Min = val[9]; } else { return false;}            // ePwm4Min -       9
      if (val[10] >=0 && val[10] <= 255) { ePwm4Max = val[10]; } else { return false;}         // ePwm4Max -       10
      if (val[11] >=0 && val[11] <= 255) { ePwm4Sr = val[11]; } else { return false;}          // ePwm4Sr -        11
      if (val[12] >=0 && val[12] <= 255) { ePwm4Ss = val[12]; } else { return false;}          // ePwm4Ss -        12
      if (val[13] >=0 && val[13] <= 1)   { ePwm4KeepLight = val[13]; } else { return false;}   // ePwm4KeepLight - 13
      
     EEPROM.write(371,ePwm4Pin); EEPROM.write(372,ePwm4Status); EEPROM.write(373,ePwm4HOn); EEPROM.write(374,ePwm4MOn);
     EEPROM.write(375,ePwm4SOn); EEPROM.write(376,ePwm4HOff); EEPROM.write(377,ePwm4MOff); EEPROM.write(378,ePwm4SOff);
     EEPROM.write(379,ePwm4Min); EEPROM.write(380,ePwm4Max); EEPROM.write(381,ePwm4Sr); EEPROM.write(382,ePwm4Ss);      
     EEPROM.write(383,ePwm4KeepLight); 
  }  

  ///////////////////////////////////////////////////////////////////////////////////////
 /////                        PWM - 5, EPROM                                       ///// 
 ///////////////////////////////////////////////////////////////////////////////////////
  if (val[0] == 91) 
  { //      1          2         3            4        5          6          7         8        9          10        11       12         13
    byte ePwm5Pin, ePwm5Status, ePwm5HOn, ePwm5MOn, ePwm5SOn, ePwm5HOff, ePwm5MOff, ePwm5SOff, ePwm5Min, ePwm5Max, ePwm5Sr, ePwm5Ss, ePwm5KeepLight;
      
      if (val[1] >=0 && val[1] <= 99) { ePwm5Pin = val[1]; } else { return false;}             // ePwm5Pin -       1 
      if (val[2] >=0 && val[2] <= 1)  { ePwm5Status = val[2]; } else { return false;}          // ePwm5Status -    2
      if (val[3] >=0 && val[3] <= 23) { ePwm5HOn = val[3]; } else { return false;}             // ePwm5HOn -       3
      if (val[4] >=0 && val[4] <= 59) { ePwm5MOn = val[4]; } else { return false;}             // ePwm5MOn -       4
      if (val[5] >=0 && val[5] <= 59) { ePwm5SOn = val[5]; } else { return false;}             // ePwm5SOn -       5
      if (val[6] >=0 && val[6] <= 23) { ePwm5HOff = val[6]; } else { return false;}            // ePwm5HOff -      6
      if (val[7] >=0 && val[7] <= 59) { ePwm5MOff = val[7]; } else { return false;}            // ePwm5MOff -      7
      if (val[8] >=0 && val[8] <= 59) { ePwm5SOff = val[8]; } else { return false;}            // ePwm5SOff -      8
      if (val[9] >=0 && val[9] <= 255) { ePwm5Min = val[9]; } else { return false;}            // ePwm5Min -       9
      if (val[10] >=0 && val[10] <= 255) { ePwm5Max = val[10]; } else { return false;}         // ePwm5Max -       10
      if (val[11] >=0 && val[11] <= 255) { ePwm5Sr = val[11]; } else { return false;}          // ePwm5Sr -        11
      if (val[12] >=0 && val[12] <= 255) { ePwm5Ss = val[12]; } else { return false;}          // ePwm5Ss -        12
      if (val[13] >=0 && val[13] <= 1)   { ePwm5KeepLight = val[13]; } else { return false;}   // ePwm5KeepLight - 13
      
     EEPROM.write(391,ePwm5Pin); EEPROM.write(392,ePwm5Status); EEPROM.write(393,ePwm5HOn); EEPROM.write(394,ePwm5MOn);
     EEPROM.write(395,ePwm5SOn); EEPROM.write(396,ePwm5HOff); EEPROM.write(397,ePwm5MOff); EEPROM.write(398,ePwm5SOff);
     EEPROM.write(399,ePwm5Min); EEPROM.write(400,ePwm5Max); EEPROM.write(401,ePwm5Sr); EEPROM.write(402,ePwm5Ss);      
     EEPROM.write(403,ePwm5KeepLight); 
  }


///////////////////////////////////////////////////////////////////////////////////////
 /////                        PWM - 6, EPROM                                       ///// 
 ///////////////////////////////////////////////////////////////////////////////////////
  if (val[0] == 92) 
  {  //      1          2         3            4        5          6          7         8        9          10        11       12         13
    byte ePwm6Pin, ePwm6Status, ePwm6HOn, ePwm6MOn, ePwm6SOn, ePwm6HOff, ePwm6MOff, ePwm6SOff, ePwm6Min, ePwm6Max, ePwm6Sr, ePwm6Ss, ePwm6KeepLight;
         
      if (val[1] >=0 && val[1] <= 99) { ePwm6Pin = val[1]; } else { return false;}             // ePwm6Pin -       1 
      if (val[2] >=0 && val[2] <= 1)  { ePwm6Status = val[2]; } else { return false;}          // ePwm6Status -    2
      if (val[3] >=0 && val[3] <= 23) { ePwm6HOn = val[3]; } else { return false;}             // ePwm6HOn -       3
      if (val[4] >=0 && val[4] <= 59) { ePwm6MOn = val[4]; } else { return false;}             // ePwm6MOn -       4
      if (val[5] >=0 && val[5] <= 59) { ePwm6SOn = val[5]; } else { return false;}             // ePwm6SOn -       5
      if (val[6] >=0 && val[6] <= 23) { ePwm6HOff = val[6]; } else { return false;}            // ePwm6HOff -      6
      if (val[7] >=0 && val[7] <= 59) { ePwm6MOff = val[7]; } else { return false;}            // ePwm6MOff -      7
      if (val[8] >=0 && val[8] <= 59) { ePwm6SOff = val[8]; } else { return false;}            // ePwm6SOff -      8
      if (val[9] >=0 && val[9] <= 255) { ePwm6Min = val[9]; } else { return false;}            // ePwm6Min -       9
      if (val[10] >=0 && val[10] <= 255) { ePwm6Max = val[10]; } else { return false;}         // ePwm6Max -       10
      if (val[11] >=0 && val[11] <= 255) { ePwm6Sr = val[11]; } else { return false;}          // ePwm6Sr -        11
      if (val[12] >=0 && val[12] <= 255) { ePwm6Ss = val[12]; } else { return false;}          // ePwm6Ss -        12
      if (val[13] >=0 && val[13] <= 1)   { ePwm6KeepLight = val[13]; } else { return false;}   // ePwm6KeepLight - 13

     EEPROM.write(411,ePwm6Pin); EEPROM.write(412,ePwm6Status); EEPROM.write(413,ePwm6HOn); EEPROM.write(414,ePwm6MOn);
     EEPROM.write(415,ePwm6SOn); EEPROM.write(416,ePwm6HOff); EEPROM.write(417,ePwm6MOff); EEPROM.write(418,ePwm6SOff);
     EEPROM.write(419,ePwm6Min); EEPROM.write(420,ePwm6Max); EEPROM.write(421,ePwm6Sr); EEPROM.write(422,ePwm6Ss);      
     EEPROM.write(423,ePwm6KeepLight); 

  }
  
  
 /////////////////////////////////////////////////////////////////////////////////////////////
 /////                        Set Date                                                   /////
 /////////////////////////////////////////////////////////////////////////////////////////////
 byte setHour, setMinute, setSecond, setYear, setMonth, setDay;
 
 if (val[0] == 40) {
   if (val[1] >=0 && val[1] <= 23) { setHour = val[1]; } else { return false;}           // setHour -   1
   if (val[2] >=0 && val[2] <= 59) { setMinute = val[2]; } else { return false;}         // setMinute - 2
   if (val[3] >=0 && val[3] <= 59) { setSecond = val[3]; } else { return false;}         // setSecond - 3
   if (val[4] >=15 && val[4] <=99 ) { setYear = val[4]+2000; } else { return false;}     // setYear -   4
   if (val[5] >=1 && val[5] <=99 ) { setMonth = val[5]; } else { return false;}          // setMonth -  5
   if (val[6] >=1 && val[6] <=31 ) { setDay = val[6]; } else { return false;}            // setDay -    5
     
   setTime(setHour,setMinute,setSecond,setDay,setMonth,setYear); // godz, min, sek, dzien, miesiac, rok

   RTC.set(now());
   return true;
 }


 ///////////////////////////////////////////////////////////////////////////////////////////
 /////                       Get Settings                                              /////
 ///////////////////////////////////////////////////////////////////////////////////////////
 if (val[0] == 66 ) 
 {
   int eAddress = 0;
   Serial.write("*66,");
   
   while (eAddress <= 512) 
    {
        Serial.print(EEPROM.read(eAddress));
        Serial.write(",");
        eAddress++;
    }
  Serial.write("#\n");
 }

 ///////////////////////////////////////////////////////////////////////////////////////////
 /////                       Get Date                                                  /////
 ///////////////////////////////////////////////////////////////////////////////////////////
 if (val[0] == 83 ) 
 {
   Serial.print("*83");
   Serial.write(",");
   Serial.print(tm.Hour);
   Serial.write(",");
   Serial.print(tm.Minute);
   Serial.write(",");
   Serial.print(tm.Second);
   Serial.write(",");
   Serial.print(tmYearToCalendar(tm.Year));
   Serial.write(",");
   Serial.print(tm.Month);
   Serial.write(",");
   Serial.print(tm.Day);
   Serial.println();
    
 }

if (val[0] == 80) 
{
  Serial.println("AQma LED Control, version 1.2.0");
}

 
 
Odpowiedź
#2
Witam
Chłopie aby sprawdzić swój moduł mógłbyś korzystać na 100% z innego, bardzo prostego sketcha. Ten tutaj nawet nie da się czytać, co dopiero ogarnąć co autor miał na myśli :-) Za dużo rzeczy w nim robisz jednocześnie. Nawet gdybym nie był "wczorajszy" to nie chciałoby mi się tego analizować. Weź po prostu podłącz to do jakiegoś pina (~) i w pętli zwiększaj Value:
czyli:

Kod:
void setup()
{
   pinMode(9,OUTPUT);
}
void loop()
{
   for(int x=0; x<255;x++)
  {
     analogWrite(9,x);
     delay(20);
  }
  delay(500);
}

Pozdrawiam
 
Odpowiedź
#3
dzięki, spróbuje w ten sposób i dam znać
 
Odpowiedź
#4
DZieki Wielkie , wreszcie działa Smile Coś było nie tak z tamtym kodem
 
Odpowiedź
#5
Hmm mam jeszcze jedno pytanie, jak zrobić żeby to rozjaśnienie i ściemnienie było wykonywane o danej porze? i zostawało na full?
I kolejny problem, nawet jak dam ten pin na low, i diody teoretycznie nie świecą, to mrugają co 1 sek , co prawda o bardzo niskim natężeniu.
 
Odpowiedź
#6
(16-01-2016, 23:18)stebciu napisał(a): Hmm mam jeszcze jedno pytanie, jak zrobić żeby to rozjaśnienie i ściemnienie było wykonywane o danej porze? i zostawało na full?
I kolejny problem, nawet jak dam  ten pin na low, i diody teoretycznie nie świecą, to mrugają co 1 sek , co prawda o bardzo niskim natężeniu.

Witam
Zakupić dowolny moduł zegara, do library wgrać potrzebną bibliotekę, zrobić z niej kilka przykładów aby zrozumieć o co biega (jakich funkcji używać)
Potem dostosować kod do swoich potrzeb i jazda :-)
Co do rozjaśniania, to co Ci dałem to tylko przykładowy kod do testu Twojego modułu. Mam prośbę do wszystkich - wklejajcie swoje kody, bo nikt z nas nie jest jasnowidzem - co kurna mamy się domyślać co Wasz kod robi??? Jak mamy pomóc gdzie jest błąd w kodzie skoro nie ma kodu?
Pozdrawiam
 
Odpowiedź
  


Skocz do:


Przeglądający: 1 gości