Arduino.ru

ну ты хоть бы на форуме поискал. тема один в один

http://arduino.ru/tutorials/BlinkWithoutDelay

Или так

вопрос стоит мигать, 100mc горит св.диод и 900 mc не горит как рас я и пляшу от этой темы

Так Вы уж определитесь Вам готовый скетч или "как реализовать"?

void setup() {                
  pinMode(13, OUTPUT);     
}

void loop() {
  int ku = millis()%1000;
  digitalWrite(13, !(ku-ku%100));
}

KVadik, гениальное решение :))

Да ну, просто выпендриваюсь :) Издержки советского образования и хождения на пары по ПТЦА. Честно говоря не понимаю студентов которым главное сдать, а не знать. :(

Действительно гениально, кокдато у одной библиотеки отжал, а тут всё так просто

boolean v5(unsigned long v6,unsigned long v7){unsigned long v8;v8=v6+v7;
return (millis()>=v8);}
boolean v1 = 1;boolean v2 = 0;boolean v3 = 0;unsigned long v4 = 0;
void setup()
{
pinMode(13, OUTPUT);
}
void loop()
{
if (v1){if(!v2){v2=1;v3=1;v4=millis();}}else{v2=0;v3=0;}if(v2){if(v3){if(v5(v4,900)){v4=millis();v3=0;}}
else{if(v5(v4,100)){v4=millis();v3=1;}}}digitalWrite(13,v3);
  }

вот спасибо а теперь буду по полчкам разлаживть, что куда и зачем я вообщето не студент с паяльником дружу давно, микропрцесоры начал разбирать не давно только очень туго с написанием кода ,еще раз спасибо будут вопросы буду писать :)

Не стал создавать новую тему, эта привлекла гениальными кусками кода)))

Кто поможет сделать одинаковое по времени изменение яркости LED ламп?

Вот код:

char arrayR[3];             // 
char arrayG[3];            // Массивы для хранения уставки считанной из порта
char arrayB[3];           //
int r = 0;                  //
int g = 0;                 // Счётчик циклов для заполнения массива уставок
int b = 0;                //
int Red = 0;                //
int Green = 0;             // Уставка цвета (считанная из порта)
int Blue = 0;             //
int REDbrightness = 0;      //
int GREENbrightness = 0;   // Уровень яркость цвета
int BLUEbrightness = 0;   //


void setup()
{
  Serial.begin(57600);
}
void loop()
{  

  if (Serial.available()>1) 
     {   
       uint8_t inByte = Serial.read();  
       
//===========RED=START========= 
        if(inByte=='R' || inByte=='r')
          { 
           if(Serial.available() > 0)
             {
               delay(5);
               while(r <= 2)
                {
                  arrayR[r] = Serial.read();
                  r++;
                }
               r = 0;
               Red = atoi(arrayR);
               arrayR[r] = 0;
             }
          }
//===========RED==END==========
//=========GREEN=START=========
        if(inByte=='G' || inByte=='g')
          { 
           if(Serial.available() > 0)
             {
               delay(5);
               while(g <= 2)
                {
                  arrayG[g] = Serial.read();
                  g++;
                }
               g = 0;
               Green = atoi(arrayG);
               arrayG[g] = 0;
             }
          }          
//=========GREEN==END==========
//==========BLUE==START========
        if(inByte=='B' || inByte=='b')
          { 
           if(Serial.available() > 0)
             {
               delay(5);
               while(b <= 2)
                {
                  arrayB[b] = Serial.read();
                  b++;
                }
               b = 0;
               Blue = atoi(arrayB);
               arrayB[b] = 0;
             }
          } 
//==========BLUE===END=========
     }

//===========RED=DIMMING=START======= 
  if (Red > REDbrightness &&  REDbrightness <= 255)
     {
      REDbrightness++;
      analogWrite(9, REDbrightness);
      /*Serial.print("REDbrightness: ");
      Serial.println(REDbrightness);
      Serial.print("RED: ");
      Serial.println(Red);
     */ }

  if (Red < REDbrightness &&  REDbrightness > 0)
     {
      REDbrightness--;
      analogWrite(9, REDbrightness);
    /*  Serial.print("REDbrightness: ");
      Serial.println(REDbrightness);
      Serial.print("RED: ");
      Serial.println(Red);
     */ }
//===========RED=DIMMING==END========
//=========GREEN=DIMMING=START=======
  if (Green > GREENbrightness &&  GREENbrightness <= 255)
     {
      GREENbrightness++;
      analogWrite(10, GREENbrightness);
      }

  if (Green < GREENbrightness &&  GREENbrightness > 0)
     {
      GREENbrightness--;
      analogWrite(10, GREENbrightness);
     }
//=========GREEN=DIMMING==END========
//==========BLUE=DIMMING=START=======

  if (Blue > BLUEbrightness &&  BLUEbrightness <= 255)
     {
      BLUEbrightness++;
      analogWrite(11, BLUEbrightness);
      }

  if (Blue < BLUEbrightness &&  BLUEbrightness > 0)
     {
      BLUEbrightness--;
      analogWrite(11, BLUEbrightness);
     }
//==========BLUE=DIMMING==END========


  delay(7);
}

Тут мы задаём в ком порт значения вида R125G255B075 и соответствующая яркость плавно выставляется на соответствующих пинах. Всё вроде хорошо... Кроме того что не равномерно. А именно - из моего примера видно, что сначала установится яркость Blue в 75, потом Red в 125 и чуть позже их догонит Green с уровнем 255. Как можно просчитать изменение brightness так, чтоб примерно за один цикл они равно приближались к заданным значениям цветов? Может я и смог бы сам сделать, но пока не представлю алгоритма даже.

определите сами, какое жестко фиксированное количество шагов надо на изменение яркости. потом, получив новые значения яркости из порта, вычисляйте для каждого цвета дельту - разность яркости, делите на количество шагов, вот и будет изменение цвета за один шаг. у каждого цвета разное.