Arduino.ru

Если я вас правельно понял, то так:

	int l=0;
	// Пять раз в секунду и так три раза = 15 раз по 1/5 секунды
	while(l<15){
		l++;
		digitalWrite(led, HIGH);
		delay(100); // (1/5)/2 - секунды
		digitalWrite(led, LOW);
		delay(100); // (1/5)/2 - секунды
	}
	l=0;
	// Три раза по секунде
	while(l<3){
		l++;
		digitalWrite(led, HIGH);
		delay(500); // 1/2 - секунды
		digitalWrite(led, LOW);
		delay(500); // 1/2 - секунды
	}

А почему именно while а не for напремер?

 2Krofa:

 Прочитайте прикрепленную ветку http://arduino.ru/forum/obshchii/vstavka-programmnogo-koda-v-temukommentarii

Что-бы два раза не вставать еще и эту http://arduino.ru/forum/obshchii/sokhranenie-kartinok-na-forume

По поводу циклов: на while вам пример уже дали. Хотя, согласен с ich, чуть красивее было-бы на for.

В общем случае все виды циклов - взаимозаменяемы. Что можно сделать на одном - то можно и на другом. Просто по ситуации смотрять "что удобней" в данный момент. Как правило когда "нужно выполнить определенное количество раз" - удобней for

Я бы порекомендовал вам теперь, сделать тоже самое и на for и на do...while  . Что-бы "быть с ними на ты".

Единственное исключения из всех управляющих операторов - оператор goto. Я бы рекомендовал даже не читать про него. Забыть как про тяжкое наследие дремучих веков. Все остальные - нужно знать обязательно.

Потом, что-бы "закрепить циклы" и "освоится с массивами" можете поробовать сделать так, что-бы все интервалы "сколько гореть/сколько не гореть", были запихнуты в один массив,а не "размазынны по коду", а потом "мигать" for-ам по этому массиву.

Спасибо огромное!
Все получилось как я и хотел.
Вроде понял как писать цикл этого вида, сейчас буду for осваивать.
 

leshak  все понял сейчас буду делать с for, спасибо за советы!
Очень  благодарен :)

 Кстати можно вообщем без цикла обойтись. Вернее "неявным циклом". Вспомнив что loop() у нас это тоже "такой цикл" который крутится бесконечно. И можно что-то делать на "его проходах".

Код конечно получается гораздо менее понятным (плюс я немного повыежачивался в нем), поэтому для вашей задачи не нужно его брать, просто "показать возможность"

int i=0;

void setup(){
  pinMode(LED_BUILTIN,OUTPUT); // Обратите внимание что LED_BUILTIN я нигде не объявлял. Недавно узнал что уже есть такая константа "из коробки" и самому дефайнить - не обязательно
}

void loop(){
  
  digitalWrite(LED_BUILTIN,!(i % 2)); // на четных проходах включаем, на нечетных выключаем
  
  if(i<30)delay(100); // быстрые мигания. Пять раз в секунду и так три раза = 15 раз по 1/5 секунды. И умножить на два (так как два прохода для включения/выклчюения)
  else delay(500); // медленные
  
  i++;

  // начинаем сначала
  if(i==36)i=0;  // (15+3)*2

}

В таком код хоть и менее "прозрачен", но от него уже один шаг подать до отказа от delay(), который во многих случаях не пременим так как полностью останавливает скетч на это время. И "пока ждем" ничего другого не происходит полезного (мигать еще и другим диодом, опрашивать кнопки и т.п.)

 Ну коль "сказал А, скажу уж и Б".

> но от него уже один шаг подать до отказа от delay()

Сделаем этот шаг

int i=0;
unsigned long lastChangeTime=0; // когда последний раз переключали LED
unsigned long changed_delay=0;  // интервал между переключениям


void setup(){
  pinMode(LED_BUILTIN,OUTPUT); // Обратите внимание что LED_BUILTIN я нигде не объявлял. Недавно узнал что уже есть такая константа "из коробки" и самому дефайнить - не обязательно
}

void loop(){
  
  if( millis()-lastChangeTime>changed_delay) { // прошло достаточно времени от прошлого переключения
  
        digitalWrite(LED_BUILTIN,!(i % 2)); // на четных проходах включаем, на нечетных выключаем
        
        // подкручиваем "интервал"
        if(i<30)changed_delay=100; // быстрые мигания. Пять раз в секунду и так три раза = 15 раз по 1/5 секунды. И умножить на два (так как два прохода для включения/выклчюения)
        else changed_delay=500; // медленные
        
        i++;
      
        // начинаем сначала
        if(i==36)i=0;  // (15+3)*2
        
         lastChangeTime=millis();// запомнили время когда переключили
  }
  
  //
  //  А вот тут пишем код, который хотим выполнять
  // "паралельно" с миганием (мигнуть другим диодом, крутить серву, послать ругань в Serial и т.п.)
  // Главное что-бы этот код сам не стопорил скетч
  // delay()-ями и т.п.

}

 Кажись "остапа понесло" :)

А вот предположим что нам заказили более "универсальное решение". Что-бы "как и сколько раз мигать" - было легко задавать/менять.

Например, кроме после ваших "5ть раз быстро и 3 раза медленно", нужно еще два раза "светить длинно, но с короткой паузой", а потом наоборот четрые раза "коротко мигнуть, и сделать длинную паузу". 

// структура для описывающая повторяющих миганий
struct TRepeatBlink
{
	
        unsigned long OnTime; // сколько нужно светить
        unsigned long OffTime; // сколько "держать паузу
        unsigned long Repeat; // сколько раз мигнуть "таким макаром"

};

TRepeatBlink commands[]={  // собственно массив который будет содержать "команды для мигания", цифры в каждой строчке - соотвествуют полям структуры TRepeatBlink
        {100,100,5}, // быстрые мигания, 5-ть раз
        {500,500,3}, // медленные мигания
        {2000,100,2}, // два раза динно, но с маленькой паузой
        {300,1000,4}// четыре "средних", но паузой в секунду
      };
      
#define COMMANDS_COUNT sizeof(commands)/sizeof(TRepeatBlink)  // вычисляем сколько у нас всего "комманд".


int current_cmd_index=0; // индекс текущей команды
int blinked=0; // сколько раз мы выполнили текущую команду, вместо i, что-бы спокойно пользоватся им для циклов
unsigned long lastChangeTime=0; // когда последний раз переключали LED
unsigned long changed_delay=0;  // интервал между переключениям


void setup(){
  pinMode(LED_BUILTIN,OUTPUT); // Обратите внимание что LED_BUILTIN я нигде не объявлял. Недавно узнал что уже есть такая константа "из коробки" и самому дефайнить - не обязательно
  for(byte i=0;i<COMMANDS_COUNT;i++)commands[i].Repeat*=2; // умножаем количество требуемых повторений на два. так как на нужно включить/выключить
}

void loop(){
  
  if( millis()-lastChangeTime>changed_delay) { // прошло достаточно времени от прошлого переключения
        TRepeatBlink cmd=commands[current_cmd_index]; // для удобства вытаскиваем текущую команду в локальную переменную
       
        bool isOn=!(blinked % 2); // включить или выключить,на четных проходах включаем, на нечетных выключаем
        digitalWrite(LED_BUILTIN,isOn); // 
        
        // подкручиваем "интервал"
        changed_delay=isOn?cmd.OnTime:cmd.OffTime;  // это такой сокращенный синтаксис для if, когда мы хоим просто присвоить по условию

        blinked++; // увеличили счетчик мигов
        
        if(blinked==cmd.Repeat){ // отмигались соклько нужно
           current_cmd_index++; // перешли к следующей команде
           blinked=0;// ее мы еще не мигали
           
           if(current_cmd_index==COMMANDS_COUNT)current_cmd_index=0; // а если команнды кончились, переходим опять к начальной
        }
        

        
         lastChangeTime=millis();// запомнили время когда переключили
  }
  
  //
  //  А вот тут пишем код, который хотим выполнять
  // "паралельно" с миганием (мигуть другим диодом, крутить серву и т.п.)
  // Главное что-бы этот код сам не стопорил скетч
  // delay()-ями и т.п.

}

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

Можно. Реальный мир таков каков есть :)  В какой-то степени я для того и писал что-бы показать разницу между "учебной задачей" и "боевой". Что-бы было видно что код которые идет в семплах и туториалах - хорош для объяснений, но не подходит для реальных задач. И когда заказчик говорит "задача простая, для програмиста на пол часа..." - вот как раз пример очень простой задачи :)

Ущерба спрашивающему - не думаю что причинил. Естественно давать это как "ответ на вопрос" - мне бы и не пришло в голову. Но ведь "учебный ответ" уже был дан, спасибо ich. Почему не "расширить горизонт"? Немного забегая вперед. Тем более что я "пошагово усложнял". В крайнем случае человек может просто проигнорировать мои ответы (а позже вернутся к ним :) ). А вот кому-то кто зачет "мигать паралельно", кому примера "Мигаем диодом без delay(), из документации, - мало, код может и пригодится.

А для спрашивающего я специально оговорил, что "для вашей задачи не нужно его брать". Да и тайны из того что меня "просто понесло" и захотелось повыеживатся - я не делал.

Ну вот у каждого свои подходы к обучению. Лично я учусь именно так. Каждая такая "непонятка" - для меня в радость. Повод погуглить и научится чему-то нового. Именно через подсматривание какой-то "зауми" в чужих примерах. Или когда кто-то сделал не так как я обычно делаю.  Очень много полезных вещей можно найти только так - в документации к ардуине их нет (а в переводной - еще меньше).

Ну и кого бы вы этим наказали? То есть просто повезло в что в тот момент я был занят и не ответил вам? Так мало нужно что-бы "сбить вас с пути"? :) Ведь чисто вероятностно один "подобный форумчанин" - будет на любом форуме :)

"Издеваются" - ну ведь это сугубо ваша субъективная интерпретация. Причем, в данном случае, - совершенно ошибочная.  Подобных мотивов небыло и в помине. Только "принести пользу" и "почесать собственное ЧСВ" (чего было больше - затрудняютсь сказать :) 

Не скрою, иногда возникает желание "поиздеватся". Но к Krofa даже мысли такой не мелькнуло. Явно видно что человек пытается сам разобратся. Старается сам прилагать усилия. И уж точно "для издевательств" я бы не стал тратить время на написание кода. Есть много других методов :)

Естественно "предпочтение подходов к обучению" у каждого индивидуальные. И каждый ждет что на форуме будут давать именно так как "он предпочитает", но согласитесь что это не возможно. К счастью теория вероятности нас выручает. Обязательно будет кто-то кто ответит как "вам понятно". С другой стороны кому-то именно мой подход больше понравится :) Все довольны.

Например я стараюсь не давать "готовых решений". Считаю более полезным "дать направление" и не лишать человека возможности самому решить задачу (попутно узнав много нового дополнительно). Причем "дать готовое" - лично для меня обычно было-бы проще-быстрее. Вы же не сомневаетесь что я мог-бы написать вариант на for-ре? ;)  А вот Maksim и AlexFisher обычно дают "готовый ответ" (это ближе к нашей традиционной системе обучения). Я не согласен с ними в этом, но считаю благом что они делают именно так - пусть оба подхода присутсвуют на форуме.

2Krofa:

Если "испугал" - простите. Если что-то не получается с for-ом - выкладывайте. Попробуем разобратся "без зауми". А если "получается" - то же выкладывайте :)  IMHO было-бы интерестно превратить ветку в пособие "мигаем диодами все-ми мыслимыми и немыслимыми способами".

пока не зима, в книжки лезть не готов (короткое уральское лето ловить надо), потому по последнему варианту кода хотелось бы получить комментарий по частям кода не описанным в обычной справке arduino

1. #define COMMANDS_COUNT sizeof(commands)/sizeof(TRepeatBlink) - определение константы с присвоением ей значения? (если да, то тип данных любой?)

2. bool isOn=!(blinked % 2); - что есть "bool"? (boolean вероятно, всели интерпретаторы одинаково охотно кушают такие сокращения?)

3 . changed_delay=isOn?cmd.OnTime:cmd.OffTime; - разверните структуру, а то смутно понятно как правильно такое написать, если самому захочется. changed_delay=OnTime если isOn=true, иначе = OffTime, так? и сложное условие вместо isOn можно ставить [типа var=(isOn==1)?var1:var2]?

пока писал, сам можно сказать разобрался.. но всё же..

А кроме книг, можно еще и гугл поспрашать. Иногда это быстрее и точнее чем спрашивать людей (им тоже лето застать хочется ;). Можно воспринимать подобный код "намек что погуглить" (или самому попробовать в скетче "поигратся" с этим словом). 

Вообщем-то смысл подобных примеров именно в том что-бы "не читать книги", а встретив незнакомую конструкцию быстренько листануть справочник языка (в арудино скетчах справочник C или C++, если в официальной доке нет)

Первый же ответ гугла на вопрос "#define"

http://ru.cppreference.com/w/cpp/preprocessor/define

Думаю это не от компилятора зависит, а от того какие библиотеки подключены и какие типы в них определены. Видимо где-то внутрях ардуины bool объявлен как синоним boolean. Вот и "скушало". Честно говоря специально - я не сокращал. Просто одновременно приходится писать не на одном языке, где-то стандартным является bool. Ну вот и пишеш как быстрее вышло. Если "че не так" - компилятор ругнется. Не ругнулся - ну и ладно. Есть подозрение что "базовым" как раз является bool, а boolean - его синоним. Но лень лезть в справчники C++ :)

А вообще, вместо boolean, можно использовать любой числовой тип (int,byte,char). 0 будет означать false, все что не ноль - true. Частенько используется это при проверке всяких массиво, когда вопрос звучит "есть хоть один элемент".

Например вместо

if(str.length>0)что-то-делаем

можно писать просто

if(str.length)

На самом деле "структурой" тут является только то что справа от знака равно. changed_delay= - это обычное присваивание. Справа это "выражение" вида

УСЛОВИЕ?ЗНАЧЕНИЕ1:ЗНАЧЕНИЕ2

если условие истино - это выражение вернет ЗНАЧЕНИЕ1, если "ложно" - ЗНАЕНИЕ2. Ну и использовать его можно в любых конструкциях где нужно получать какое-то значение. Главное что-бы ЗНАЧЕНИЕ1 и ЗНАЧЕНИЕ2 имели один и тот же тип. Иначе компялитор не сможет понять какой типа возвращается вся конструкция.

То есть, например если бы мы хотели сообщать в серил что-же именно мы сделали, то можно было написать так

Serial.println(isOn?"LED is on":"LED is off");

Вместо

if(isOn)Serial.println("LED is on");
else Serial.println("LED if off");

Согласитесть что первый вариант намного читабельней.  Вообщем "особого смысла" эта конструкция не несет. Это просто "синтаксически сахар". 

Ну так в этом и весь смысл :)  Если бы я не "пугал новичка",  то и вы бы этими вопросами - не задались.

А можно было-бы написать самому пару тестовых скетчей, самопроверить свое "разобрался".

железа дома нет, всё на работе. не уверен что мне удастся отстоять право дома паяльником дымить, а если не дымить, то и код не нужен. потому проверить не на чем просто.

Если есть сама дуина, то можно и не дымить. В изучении языка практически все можно сделать с помощью Serial.print и диода. А если использовать готовые шилды - то и че-то полезное можно без паяльника.

А еще есть "беспаячные макетки". То же для эксперементов "без паяльника". Очень их люблю. Накупил их как дурень фантиков. И не использую (все время на чистый программинг уходит) :(

Я уж не вспоминаю про Proteus и проч. эмуляторы. Вообщем - было бы желание :)

P.S. А еще можно добится четкого запрета "нельзя дымить паяльником, все остальное - можно". И купить фен-паяльный :) Социальную инженерию никто не отменял ;), но IMHO л

финансовый достаток дело интимное..

Окошком ошиблись? ;) Вроде про достаток никто не спрашивал :)

Возник вопрос с управлением яркости светодиода.

Пример брал с arduino.ru/tutorials/BlinkWithoutDelay
 а если нету ~ такого знака  на порте, то этот пример работать не будет?
 

/*
 Пример управления яркостью светодиода
 на выходе 9 контроллера Arduino
 функцией analogWrite().
 */
int brightness = 0;    // уставливаем начально значение яркости
int fadeAmount = 5;    // шаг приращения/убывания яркости

void setup()  {
  // устанваливаем пин 9 в режим выхода
  pinMode(9, OUTPUT);
}

void loop()  {
  // устанавливаем значение широты импульса на выходе 9
  // задавая яркость светодиода
  analogWrite(9, brightness);    

  // измением значение в переменной для яркости
  brightness = brightness + fadeAmount;

  // при достижение крайних значений для яркости
  // меняем знак переменной шага приращения/убывания яркости 
  if (brightness == 0 || brightness == 255) {
    fadeAmount = -fadeAmount ;
  }    
  // делаем паузу для достижения плавного наращивания/убывания яркости   
  delay(30);                            
}

Плата ардуино уно 
 
 Подскажите пожалуйста!
 

 Идем http://arduino.ru/Hardware/ArduinoBoardUno

Читаем 

 Где-то видим в списке 13-ты пин? Нет. Вывод: аппаратного ШИМ (PWM)  на 13-том пине у уны нет.

Варианты действий:

• Использовать внешний диод на каком-то из вышеперечисленных пинов
• Попытатся сделать програмный шим. Самому или погуглить типа "Arduino software pwm library"

Ну или немного "почесать пятку левым ухом": в качестве "внешного диода" использовать 13-тый. Выводить шим на какой-то пин из списка и соеденить его проводком с 13-тым. Сам 13-тый при этом "на выход" не включать (а то можно и упалить). Поэтому вначале "залить скетч", потом уже соединять. Варинат "чуток стремный" (на 1%, ну просто потому что лень для увереность в даташиты лезть что-бы перепроверить как-там диод подключен), но только что проверели на своей меге. Дыма не пошло. Диод плавно меняет яркость.

 Вообщем взял ваш скетч. Нормально он работает (потому что у меня мега у нее есть на 13-том шим).

Далее поменял в вашем скетче 13-ты на 9-тый (строки 11 и 17). Залил. Соеденил проводком 13-тый и 9тый пин. Все опять заработало.

Только что попробовал на внешнем диоде, все заработало!

 "в качестве "внешного диода" использовать 13-тый"
вот это я и хочу зделать что бы 13-тый использовать как внешний диод

Ну я же вроде в предыдущем посте (#17) пошагово написал как это сделать. И даже попробовал у себя.

Кстати мы так и не дождались вашего варианта решения на "for" и "do-while" изначальной задачи ветки . А то у меня "еще есть идеи" как эту задачу можно решать ;)

 >Попытатся сделать програмный шим.

В какой-то мере он у важ уже есть сделаный. Выше по ветке. Это же и есть софтварный (програмный)  PWM. Взять какой-нибудь из вариантов решения сделать поменьше интервалы "светить-пауза".И будет вам "светить в пол накала". Соотношение "светить-пауза" и будет яркостью диода. Если светить и пауза - равны получится яркость 50% . Если пауза 0 - полная яркость, светить 3 миллисекунды, пауза 7 миллисекунд - 30% яркости

Если мерцания будут видны на глаз - перейти на микросекунды. Заменить millis()->micros(). 

Вот сделал плату из 8 светодиодов ( светодиот, резистор(220 ом) и на ардуино )
И сделал 4 кнопки ( кнопка, конденсатор на 10 мкф, резистор и на ардуино)

Посмотрев пару примеров, написал скетч что бы они зажигались от 1-го до 8-го светодиода и обратно.
Захотел что бы когда нажимаешь одну кнопку скорость их "ходьбы" увеличивалась, а нажав на другую уменьшалась.
Ворде работало, но кнопка сробатывала только когда горел 1-й светодиот и надо успеть нажать на кнопку что бы оно увеличело свою скорость но когда доходит до максимума, начинает гореть 1-й светодиод..надо сбрасывать каждый раз.
Вот скетч 

int time = 200;
int switchPin = 3;
int switchPin1 = 1;
int buttonState = 0;
int buttonState1 = 0;
void setup() {                

  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);  
  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(switchPin, INPUT);
  pinMode(switchPin1, INPUT);
}


void loop() {
buttonState = digitalRead(switchPin);
buttonState1 = digitalRead(switchPin1);
 
 
  if (buttonState == HIGH)
  {
    time = time + 50;
  }
 if (buttonState1 == HIGH)
  {
    time = time - 50;
  }
  if (time >= 400 && time <= 50)
  {
    time = 50;
  }

  digitalWrite(5, HIGH);   
  delay(time);           
  digitalWrite(6, HIGH);
  delay(time);
  digitalWrite(7, HIGH);
  delay(time); 
  digitalWrite(8, HIGH);
  delay(time); 
  digitalWrite(9, HIGH);
  delay(time); 
  digitalWrite(10, HIGH);
  delay(time); 
  digitalWrite(11, HIGH);
  delay(time);
  digitalWrite(12, HIGH);
  delay(time);
  digitalWrite(11, HIGH);
  delay(time);
  digitalWrite(10, HIGH);
  delay(time);
  digitalWrite(9, HIGH);
  delay(time);
  digitalWrite(8, HIGH);
  delay(time);
  digitalWrite(7, HIGH);
  delay(time);
  digitalWrite(6, HIGH);
  delay(time);
 
}
  

 Подправте если что не так :)
 

 Все "не так".

Все началось с того, что вы так и не написали свой вариант c "for и while", а значит не освоились с циклами. Отсюда пошло громадное дублирование кода, в которую "вносить поправки" - практически не возможно (вернее "возможно", но это "мартышкин труд в чистом виде"). 

Вот скажу я вам, что "вам нужно читать кнопки и выставлять время перед каждым delay()". Поменяв пару строчек сможете это сделать? Почему строчки 39-66 не сделаны в виде цикла? 

В этом случае вы добъетесь "приемлимой работы", реагировать на кнопки будет "на каждом диоде", а не только на первом.

Но по прежнему будет "плевать на кнопки", пока выполняется delay. Изменения будут происходить только "в момент перехода к диоду"

Если это не критично, то так и оставить, а если критично - перечитать ветку. В сообщение #4 я упоминал что "в боевых задачах" использование delay() крайте не желательно. И сказал почему, а в #5 показал один из подходов которым можно пользоватся что-бы "избежать использования delay()".

Если нужно "ну вообще четкое срабатывание кнопки" - можно почитать про функцию attachIntterupt. Но лезть туда, если нет уверенной работы с базовыми управляющими структурами (for,if ит.п.) - смысла не имеет.

Да, немного поняв цикл "if" подумал что мне пока его хватит. И пользовавшись той информацией которой владел, я и делал код.

Если бы я знал как для них сделать цикл, я бы сделал. Была мысль как то написать, если включен 1 светодиод включается другой, если другой включен, включается третий... и т.д. как  то так, но записать в виде цикла не получилось и начал делать дублированием :)
 

Учитывая что if это не цикл, а "условный оператор" или "оператор ветвления", то и его и циклы вы поняли весьма условно :)

Но вот оказалось что это инфы "мало".

А как это можно узнать, если не "читать" и не "пробовать"? Вернитесь "на шаг назад", к своей "прошлой задаче". Разберитесь досконально с ней. Освойте, все-таки, цикл for, а потом уже переходите "к следующим". А то вы "пошли дальше", не сделав домашние задание по прошлой. Тем более что 90% решения ich вам уже дал. Уже написал "циклом", осталось только сменить тип цикла . Вчитататся в документацию на while и for, понять их отличие (весьма косметическое). И попробоватьп переписать пример ich с циклом for.

Потом свой скетч из #22 переписать на for. Что-бы "без дублирование". Пусть он работает точно-так же как и сейчас (то есть немного неправильно), пусть делает "то же самое". Но будет в два раза меньше по размеру.

А потом уж и "с кнопками" можно начинат боротся, а потом (если нужно) с delay()-ями.

Я выше по ветке раза три писал "сделайте на for", "давайте свой пример".... от вас даже попыток никаких небыло видно. Даже банального ответа. 

Один раз ich уже сделал "за вас", вы думаете вам всегда будет так везти? И будет кто-то садится и переписывать ваши скетчи?

Все понял капитан :)
Прочитаю, разберусь, освою!

p.s.
 У вас skype есть? :)  Krofan  

Не сомневаюсь :) Благо для этого не обязательно "родится гением програмирования", достаточно желания и времени (не так уж и много). 

Просто трудно говорить про "стихотворные рифмы" если "алфавит известен через одну букву". А в нашем случае алфавит это http://arduino.ru/Reference . Любые ответы на любые "программерские вопросы" в любом случае будут оперировать "теми буквами".

Можете почитать что-нибудь по програмированию. Не обязательно "про ардуино". В любом языке популярном ныне языке вы найдете и for, и if, и переменные и типы. И все это "в первых главах". И логика работы у них у всех будет одинаковая. Это как секс :) По русски и английски пишется по разному, звучит похоже, а суть - вообще одна :)

Попробуйте почитать про циклы из "разных источников". Может где-то понятней будет. Например в википедии Цикл (программирование). Или по C или C++ какой-нибудь учебник.

Да. У меня есть skype. :)

Да уже читаю. Называется "Основы программирования по Arduino".
Вроде подробно все рассписано.

Напишите свой скайп, или добавте меня пожайлуста, ник Krofan.
Просто если какой-то вопрос возникнет что бы каждый раз сюда не писать, а то лишний флуд в ветке.
А вы человек хорошо в программировании разберающийся, подскажете или поставете на путь верный :)

Не обижайтесь, но бесплатные консультации - только на форуме. 

Причины:

• Если я буду всех желающих консультировать в скайпе - мне нечего будет есть. А времени "на всех" все равно не хватит.
• Ваши вопросы и мои ответы - могут быть полезны не только вам, но и другим. Значит КПД расхода времени - выше.
• Кроме меня могут и другие отвечать. Либо быстрее меня, либо вместо меня, либо поправят меня (я тоже могу ошибатся). Да и "стиль" ответов - отличается. Может быть не поймете мое объяснение, зато понятно будет "от %ДругойФорумчанин%" :) 
• На форуме я могу отвечать когда мне удобно и есть настроение. У программеров есть такой ценный ресрус как "сосредоточенность", а скайпы как бы немного отвлекают :) Поэтому он - только для работы.
•  

Если вопрос коррелирует с темой - почему бы и не пофлудить? Если "ну совсем не относится" - можно и новую ветку завести (естественно предварительно поискав, а нет ли уже заведенной)

Вечер добрый.

Я новичок на форуме и в ардуино тем более.

С радиоэлектроникой немного знаком  буквально совсем чуток, еще в СССР в школе немного увлекался, когда блоки питания были на железных трансформаторах и еще помню МП42 и КТ315 J, на уровне спаять схему из журнала и почти не понимая  как она работает.

Ардуино стартовый набор купил в Китае , заняться решил исключительно ради хобби что бы убивать долгие зимние вечера, пиво с мужиками и зыринг в ящик мне не интересны.

Уже есть электровелосипед на LiPo батареях, и несколько радиоуправляемых самолетов в гараже. Но сезон полетов и велосипеда уже проходит…

Ну это для знакомства J

А теперь по делу

Написал сам уже первый код « моргаем диодом»

Вот мой второй код «светофор»

Просидел весь вечер, но написал!

Зажигаем красный на 8 сек.

Затем желтый на 3 сек и красный 3 сек. горят вместе

Тушим красный и желтый

Зажигаем зеленый на 8 сек. и потом им же моргаем 6 раз.

Тушим зеленый

Зажигаем желтый на 3 сек.

Тушим желтый

И далее по кругу

Сначала применил оператор for, для повторения цикла коротких морганий зеленого.

Все работает отлично.

Затем решил применить оператор while

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

Вот собственно вопрос – так и должно быть или я чего то неправильно сделал?

Да и с оператором  do…while  сложности, как программа до него доходит зеленый начинает мигать и не выходит из этого состояния.

Вот рабочий код

 int redPin=9;    // номера выводов светодиодов
 int yellowPin=8;
 int greenPin=10;
 int i=0;
void setup()
   {
     pinMode(redPin,OUTPUT);   //устанавливаем пины на выход
     pinMode(yellowPin,OUTPUT);
     pinMode(greenPin,OUTPUT);  
   }
void loop()
    { 
      digitalWrite(redPin,1);     // зажигаем красный единичкой                             
      delay(8000);                //   ждем 8 секунд
      digitalWrite(redPin,1);     //   опять мгновенно зажигаем красный
      digitalWrite(yellowPin,1);  //  и желтый
      delay(3000);                // ждем 3 сек.
      digitalWrite(redPin,0);     //гасим одновременно красный
      digitalWrite(yellowPin,0);  // и желтый
      delay(100);                 // чуток ждем что бы было почти как по настоящему :)
      digitalWrite(greenPin,1);   // зажигаем зеленый
      delay(8000);                // ждем 8 сек.
      digitalWrite(greenPin,0);   // выключаем зеленый
      delay(300);                 // чуток ждем
    for(int i=0; i<6;i++)         // запускаем цикл for 6 раз должно выполнится то что ниже в скобках
    {
      digitalWrite(greenPin,1);
      delay(300); 
      digitalWrite(greenPin,0);
      delay(300); 
    }
      digitalWrite(yellowPin,1);  // ну и дальше в том же духе
      delay(3000);
      digitalWrite(yellowPin,0);
      delay(100); 
    }

А этот код с  оператором while

 int redPin=9;    // номера выводов светодиодов
 int yellowPin=8;
 int greenPin=10;
 int i=0;
void setup()
   {
     pinMode(redPin,OUTPUT);   //устанавливаем пины на выход
     pinMode(yellowPin,OUTPUT);
     pinMode(greenPin,OUTPUT);  
   }
void loop()
    { 
      digitalWrite(redPin,1);     // зажигаем красный единичкой                             
      delay(8000);                //   ждем 8 секунд
      digitalWrite(redPin,1);     //   опять мгновенно зажигаем красный
      digitalWrite(yellowPin,1);  //  и желтый
      delay(3000);                // ждем 3 сек.
      digitalWrite(redPin,0);     //гасим одновременно красный
      digitalWrite(yellowPin,0);  // и желтый
      delay(100);                 // чуток ждем что бы было почти как по настоящему :)
      digitalWrite(greenPin,1);   // зажигаем зеленый
      delay(8000);                // ждем 8 сек.
      digitalWrite(greenPin,0);   // выключаем зеленый
      delay(300);                 // чуток ждем
    while(i<6)                    // запускаем цикл while как бы 6 раз должно выполнится то что ниже в скобках
    {
      digitalWrite(greenPin,1);
      delay(300); 
      digitalWrite(greenPin,0);
      delay(300); 
     i++; 
    }
      digitalWrite(yellowPin,1);  // ну и дальше в том же духе
      delay(3000);
      digitalWrite(yellowPin,0);
      delay(100);
      
    }

ну вы бы перед 25-й строкой инициализацию переменной i впиндюрили - а то после первого прохода блока она у вас принимает значение 6 и блокирует вход в while-блок

Спасибо!

Да действительно все получилось. Аж стыдно стало (

Сейчас еще поганяю разные цыклы что бы понятней стало.

do...while тоже пошло !

Добрый день! Практиковался с миганиями, наткнулся на эту тему, очень заинтересовал пример товарища leshak

// структура для описывающая повторяющих миганий
struct TRepeatBlink
{
	
        unsigned long OnTime; // сколько нужно светить
        unsigned long OffTime; // сколько "держать паузу
        unsigned long Repeat; // сколько раз мигнуть "таким макаром"

};

TRepeatBlink commands[]={  // собственно массив который будет содержать "команды для мигания", цифры в каждой строчке - соотвествуют полям структуры TRepeatBlink
        {100,100,5}, // быстрые мигания, 5-ть раз
        {500,500,3}, // медленные мигания
        {2000,100,2}, // два раза динно, но с маленькой паузой
        {300,1000,4}// четыре "средних", но паузой в секунду
      };
      
#define COMMANDS_COUNT sizeof(commands)/sizeof(TRepeatBlink)  // вычисляем сколько у нас всего "комманд".


int current_cmd_index=0; // индекс текущей команды
int blinked=0; // сколько раз мы выполнили текущую команду, вместо i, что-бы спокойно пользоватся им для циклов
unsigned long lastChangeTime=0; // когда последний раз переключали LED
unsigned long changed_delay=0;  // интервал между переключениям


void setup(){
  pinMode(LED_BUILTIN,OUTPUT); // Обратите внимание что LED_BUILTIN я нигде не объявлял. Недавно узнал что уже есть такая константа "из коробки" и самому дефайнить - не обязательно
  for(byte i=0;i<COMMANDS_COUNT;i++)commands[i].Repeat*=2; // умножаем количество требуемых повторений на два. так как на нужно включить/выключить
}

void loop(){
  
  if( millis()-lastChangeTime>changed_delay) { // прошло достаточно времени от прошлого переключения
        TRepeatBlink cmd=commands[current_cmd_index]; // для удобства вытаскиваем текущую команду в локальную переменную
       
        bool isOn=!(blinked % 2); // включить или выключить,на четных проходах включаем, на нечетных выключаем
        digitalWrite(LED_BUILTIN,isOn); // 
        
        // подкручиваем "интервал"
        changed_delay=isOn?cmd.OnTime:cmd.OffTime;  // это такой сокращенный синтаксис для if, когда мы хоим просто присвоить по условию

        blinked++; // увеличили счетчик мигов
        
        if(blinked==cmd.Repeat){ // отмигались соклько нужно
           current_cmd_index++; // перешли к следующей команде
           blinked=0;// ее мы еще не мигали
           
           if(current_cmd_index==COMMANDS_COUNT)current_cmd_index=0; // а если команнды кончились, переходим опять к начальной
        }
        

        
         lastChangeTime=millis();// запомнили время когда переключили
  }
  
  //
  //  А вот тут пишем код, который хотим выполнять
  // "паралельно" с миганием (мигуть другим диодом, крутить серву и т.п.)
  // Главное что-бы этот код сам не стопорил скетч
  // delay()-ями и т.п.

}

на его основе я успешно сделал несколько примеров с двуями диодами и тд. 

но вот в чем дело, код достаточно не простой, подумал я, в частности некоторые моменты для меня непонятны, вроде !(i % 2) включение\выключение на выходе\выходе. решил сделать постаринке, простой сменой состояния LOW на HIGH ( и наоборот). но как я не старался, ничего не выходит.

подскажие, что не так

struct led_blink{
  unsigned long on,off,repeat;
};
led_blink modes1[]={
  {50,50,3},
  {200,200,5}
};
#define count_modes1 sizeof(modes1)/sizeof(led_blink)

int modes1_index=0;
int blinked1=0;
unsigned long lastChange1;
unsigned long changeDelay1;

void setup() {
pinMode(12, OUTPUT);

}
int ledState=0;
void loop() {
if ( (millis()-lastChange1)>changeDelay1){
  digitalWrite(12, ledState);
  
  if (ledState==LOW){
    changeDelay1=modes1[modes1_index].on;
    ledState=HIGH;
  } else {
    changeDelay1=modes1[modes1_index].off;
    ledState=LOW;
  }
  blinked1++;
  if (blinked1==modes1[modes1_index].repeat){
    modes1_index++;
    blinked1=0;
    if (modes1_index==count_modes1){
      modes1_index=0;
    }
  }
 lastChange1=millis();
 
 
}

 

}

как вот этот момент 

 bool isOn=!(blinked % 2); // включить или выключить,на четных проходах включаем, на нечетных выключаем
        digitalWrite(LED_BUILTIN,isOn); // 
        
        // подкручиваем "интервал"
        changed_delay=isOn?cmd.OnTime:cmd.OffTime;  // это такой сокращенный синтаксис для if, когда мы хоим просто присвоить по условию

oban, а теперь ознакомьтесь с этой темой. http://arduino.ru/forum/programmirovanie/klassy-arduino-po-qwone-dlya-chainikov

извините, но это никак не решает мою проблему. есть несколько примеров похожих, и в то же время совсем других. я прошу совета для моего "частного" случая. да и ваш метод "усложнения кода" добавлянием всюду и везде своих классов, мне не очень по душе.  

Товарища leshak-а давно нет. Консультатнтом-наследником он тоже не обзавелся. "Ваша душа" для меня потемки. Так что ищите свои "душевные подходы" к программированию ардуины, потому "мои усложнения" это просто упрощение реального нормального программирования.

если вы не можете( не желаете ) помочь, к чему вообще наш разговор?

по вашим примерам, вашей темы: вместо того, что бы просто обьявить переменные, задать входы\выходы setup(), описать выполнение в loop и на этом закончить, вы сперва создаете лишний класс, затем пару лишних ( причем идентичных по названию) методов, что бы вызвать их в этих самых индентичных, стандартных операторах setup и loop. без которых, собственно, код выглядит куда проще, к тому же короче и понятнее. если это не усложнение, то что это?

Прежде всего это начало объектного подхода в программировании. Ведь ресурсов Ардуины хватает на больше чем мигать светодиодом. Вот и создаются независимые обекты программы. А что бы они не только занимали место в исходнике и во флеш памяти но и работали надо их инициализировать и периодически давать работать. Вот и приходится использовать методы init() и run(). не нравится класс. То будут функции initUnit1() и runUnit1(). А потом их разместить в системном setup и loop . Надо отключить эти компоненты . То их просто закоментировать. А компилятор их уберет из программы не трогая исходник. Но вы похоже ищите посложнее, что бы чуть что бежать на форум.

/**/
//----Unit 1---------------------------------
void initUnit1() {
  /*текст*/
}
void runUnit1() {
  /*текст*/
}
//----Unit 2--------------------------------
void initUnit2() {
  /*текст*/
}
void runUnit2() {
  /*текст*/
}
//-------------------------------------
void setup() {
  initUnit1();
  initUnit2();

}
void loop() {
  runUnit1();
  runUnit2();
}
/**/

А вот убрали компонент 1 из программы. Ну к примеру вычислить что мешает работе системы в целом

/**/
//----Unit 1---------------------------------
void initUnit1() {
  /*текст*/
}
void runUnit1() {
  /*текст*/
}
//----Unit 2--------------------------------
void initUnit2() {
  /*текст*/
}
void runUnit2() {
  /*текст*/
}
//-------------------------------------
void setup() {
  //initUnit1(); //<-- убрали компонет 1 из программы
  initUnit2();

}
void loop() {
  //runUnit1();//<-- убрали компонет 1 из программы
  runUnit2();
}
/**/

/**/
//----Unit 1---------------------------------
void initUnit1() {
  /*текст*/
}
void runUnit1() {
  /*текст*/
}
//----Unit 2--------------------------------
void initUnit2() {
  /*текст*/
}
void runUnit2() {
  /*текст*/
}
//-------------------------------------
void setup() {
  //initUnit1(); //<-- убрали компонет 1 из программы
  initUnit2();

}
void loop() {
  //runUnit1();//<-- убрали компонет 1 из программы
  runUnit2();
}
/**/

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

я уверен, на форуме полно людей, для которых мой пример элементарен, и поправить/добавить пару строк не отнимет много времени. возможно придеться создать новую тему, ибо эта мертва., но я решительно намерен разобраться. 

проблема решена, заменил таким вот способом

int ledState=0;
void loop() {
if ( (millis()-lastChange1)>changeDelay1){
   if ( ledState==LOW)ledState=HIGH;
   else ledState=LOW;
  if((blinked1<modes1[modes1_index].repeat)&&ledState==HIGH){
    changeDelay1=modes1[modes1_index].on;
  }
  if((blinked1<modes1[modes1_index].repeat)&&ledState==LOW){
    changeDelay1=modes1[modes1_index].off;
  }
 digitalWrite(12, ledState);
  blinked1++;
  if (blinked1==modes1[modes1_index].repeat){
    modes1_index++;
    blinked1=0;
    if (modes1_index==count_modes1){
      modes1_index=0;
    }
  }
 lastChange1=millis();
 
 
}

Все изящней решается. Можно и управлять. А можно и мигагать в разнобой на разных ногах

/**/
unsigned long mill;
//------------------------------------
typedef struct { /*формат записи программы*/
  byte maxTick;         // количество миганий
  unsigned long OnTick; // сколько нужно светить
  unsigned long OffTick; // сколько "держать паузу
}  Tick_t;
enum {sStop = 0, sStart, sOnTick, sOffTick, sPause};
class Cl_Blinker {
  protected:
    byte pin;/*нога*/
    Tick_t *prog;
    unsigned long past, interval;
    const unsigned long pause = 1000;/*длительность паузы между сериями*/
    byte iTick, iPeriod, maxTick, maxPeriod;
    byte state;
    void stand(byte s) {
      state = s;
      past = mill;
      switch (state) {
        case sStop:
          digitalWrite(pin, LOW);
          break;
        case sStart:
          iTick = 0;
          iPeriod = 0;
          maxTick = prog[iPeriod].maxTick;
          state = sOnTick;
        case sOnTick:
          interval = prog[iPeriod].OnTick;
          digitalWrite(pin, HIGH);
          break;
        case sOffTick:
          interval = prog[iPeriod].OffTick;
          digitalWrite(pin, LOW);
          break;
        case sPause:
          interval = pause;
          break;
      }
    }
  public:
    Cl_Blinker(byte p, Tick_t *pr, byte s)
      : pin(p), prog(pr), maxPeriod(s) {}
    void init() {
      pinMode(pin, OUTPUT);
      stand(sStop);
    }
    void run() {
      if (state == sOnTick  && mill - past >= interval) stand(sOffTick);
      if (state == sOffTick && mill - past >= interval) {
        iTick++;
        if (iTick >= maxTick) {
          iPeriod++;
          if (iPeriod >= maxPeriod) {
            stand(sPause);
            return;
          }
          else {
            iTick = 0;
            maxTick = prog[iPeriod].maxTick;
            stand(sOnTick);
          }
        }
        else  stand(sOnTick);
      }
      if (state == sPause   && mill - past >= interval) stand(sStart);
    }
    void start() {
      stand(sStart);
    }
    void stop() {
      stand(sStop);
    }
};
//------Компоновка-------------------------------
Tick_t prog[] = {
  /* maxTick OnTick OffTick*/
  {3, 100 , 100}, // 3 коротких
  {3, 500 , 100}, // 3 длиных
  {3, 100 , 100}, // 3 коротких
};
byte step = sizeof(prog) / sizeof(Tick_t); // вычисляем сколько у нас всего "комманд".
Cl_Blinker Blinker(/*пин*/13,/*программа*/prog,/*количество*/step);
//---------Main----------------------------
void setup() {
  Blinker.init();
  Blinker.start();
}

void loop() {
  mill = millis();
  Blinker.run();
}
/*Скетч использует 1640 байт (5%) памяти устройства. Всего доступно 30720 байт.
  Глобальные переменные используют 61 байт (2%) динамической памяти, оставляя 1987 байт для локальных переменных. Максимум: 2048 байт.
*/

Проще всего - ходить пешком. 

Но если возникает потребность за день доставить несколько тонн груза за несколько сотен км, то приходится усложнять: изучать ПДД, учиться водить автомобиль, сдавать на права...

Зачем, если ходить пешком и нести в руках проще и понятнее?

А что касается Вашего конкретного примера, то Вам следует почитать о языке, на котором Вы пытаетесь писать. Обсуждать элементарные конструкции здесь считается mauvais ton. Форум посвящен особенностям программирования для Ардуино, а не обучению основам языка.

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

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

А подумать, то и автомат морзе можно сделать.

oban, Вы впервые отписались в этой теме в сообщении №33. Слово "проблема" Вы в нем не упоминали, но присутствующим и без того стало ясно, что Ваша проблема - в незнании языка, на котором Вы пытаетесь писать.

В сообщении №35 Вы уже упоминаете о том, что у вас есть проблема и Вы хотите ее решить. 

А между тем, уже в сообщении №34 Квон сделал попытку помочь Вам в решении Вашей проблемы. Да, собственно, и остальные его посты направлены на то же самое.

Но Если Вы считаете, что самит лучше знаете, что Вам нужно, то берите книжку Кернигана и Ритчи и читайте ее до полного прсветления.

PS. А по поводу Вашей аллегории: чтобы суметь понять, где нужен автомобиль, а где удобнее пешком, нужно иметь этот автомобиль, уметь его водить и, кроме того, иметь хотя бы минимальный опыт его эксплуатации. Без этого, извините, Ваше мнение о том, когда на автомобиле, а когда - пешком, никак нельзя признать компетентным.

нужно обязательно иметь танк, что бы понять, что он жрет соляры в разы больше автомобиля. без этого, извините, никак не разобраться же. я не знаю насколько в программировании вы хороши ( честно -сомневаюсь , что хороши), но с логикой у вас проблемы. извините за откровенность.

с управлением кнопкой проблем у меня не было.

да и вообще, пора прекращать этот бесполезный разговор. ибо он плавно отошел от решения моей проблемы ( которуя я уже решил самостоятельно) к навязыванию мне вашего видения.