Arduino.ru

#299

тоже самое.....
"придётся собрать схемку, а не виртуально обсуждать :)    отпишусь"

крайнюю версию кода, пожста, сюда..... буду мучить его, но только с утра 27-го :(

#define DEBUG 1      // определили - ОТЛАДКА , закомментить - значит не определили

#define knopka1 2
#define knopka2 3
#define knopka3 4
  #define ledLive1 10
  #define ledLive2 9
  #define ledLive3 8
#define ledAssignment1 5
#define ledAssignment2 6
#define ledAssignment3 7
 #define ledBlockButtons 11
byte levelCurrent=1;
byte levelMax=10;
byte liveCurrent=3;
 enum SECTION{sectionOut,sectionIn,sectionResult};
 SECTION section=sectionOut;
unsigned long oldMillis;
 byte assignment[10];
 byte reply[10];
 byte countKnopka;   // колво нажатий на кнопки ввода ответа
//=========================================================================
void setup()
{
  Serial.begin (9600);
  pinMode (knopka1,INPUT);
  digitalWrite(knopka1,HIGH);
  pinMode (knopka2 ,INPUT);
  digitalWrite(knopka2,HIGH);
  pinMode (knopka3,INPUT);
  digitalWrite(knopka3,HIGH);
    pinMode (ledAssignment1,OUTPUT);
    pinMode (ledAssignment2,OUTPUT);
    pinMode (ledAssignment3,OUTPUT);
    OutByteAssignment(0);
  pinMode (ledLive1,OUTPUT);
  pinMode (ledLive2,OUTPUT);
  pinMode (ledLive3,OUTPUT);
  OutByteLive(0);
    pinMode (ledBlockButtons,OUTPUT);
    digitalWrite(ledBlockButtons,LOW);
  randomSeed (analogRead(0));
   oldMillis=millis();
}
//=========================================================================
void loop()
{
// sectionOut
  if(section==sectionOut)
  {
    ClearAssignment();
    for(byte i=0;i<levelCurrent;i++)
    {
      if(i==0) assignment[0]=RandomByte();
      if(i>0)
      {
        byte tempByte=RandomByte();
        while(assignment[i-1]==tempByte)
        {
          tempByte=RandomByte();
        }
        assignment[i]=tempByte;
      }
    }
    for(int i=0;i<5;i++)
    {
      OutByteLive(7);
      delay(100);
      OutByteLive(0);
      delay(100);
    }
    OutByteLive(liveCurrent);
    delay(1000);
    OutByteLive(0);
    OutByteAssignment(7);
    delay(1000);
    OutByteAssignment(0);
    delay(1000);
    byte n=0;                            // начало миганий задания
    while((assignment[n]!=0)&&(n<10))
    {
      OutByteAssignment(assignment[n]);  // вкл случСД
      delay(500);                        // пауза
      OutByteAssignment(0);              // выкл случСД
      delay(500);                        // пауза
      n++;
    }                                    // окончание миганий задания
    delay(500);
    OutByteAssignment(7);
    delay(500);
    OutByteAssignment(0);
    digitalWrite(ledBlockButtons,HIGH);
#ifdef DEBUG // смотрим что навводили в массив задание В РЕЖИМЕ ОТЛАДКА
          Serial.print(" level = ");
          Serial.println(levelCurrent);
          for(byte i=0;i<10;i++)
          {
            Serial.print(assignment[i]);
            Serial.print(" ");
          }
          Serial.println("");
#endif // окончание просмотра массива задание
    Serial.println(" GO ! Push button !!!");
    ClearReply();
    countKnopka=0;
    section=sectionIn;
    oldMillis=millis();
  }

// sectionIn
  if(section==sectionIn)
  {
    if((millis()-oldMillis)<(2000+levelCurrent*500))
    {
// считывание и запись нажатий кнопок в массив
      if(countKnopka<10)      // чтобы не вылезти за границы массива
      {
        if(!digitalRead(knopka1))
        {
          delay(50);            // для антидребезга контактов кнопки
          reply[countKnopka]=1;
          countKnopka++;
        }
        if(!digitalRead(knopka2))
        {
          delay(50);            // для антидребезга контактов кнопки
          reply[countKnopka]=2;
          countKnopka++;
        }
        if(!digitalRead(knopka3))
        {
          delay(50);            // для антидребезга контактов кнопки
          reply[countKnopka]=4;
          countKnopka++;
        }
      }
// окончание считывания и записи нажатий кнопок в массив
    }
    else
    {
      // .........................
      digitalWrite(ledBlockButtons,LOW);
      Serial.println("...allotted time has expired !");
      section=sectionResult;
    }
  }

// sectionResult
  if(section==sectionResult)
  {
#ifdef DEBUG // смотрим что навводили в массив ответов В РЕЖИМЕ ОТЛАДКА
    for(byte i=0;i<10;i++)
    {
      Serial.print(reply[i]);
      Serial.print(" ");
    }
    Serial.println("");
    Serial.println("************************");
#endif // окончание просмотра массива ответов В РЕЖИМЕ ОТЛАДКА
    // .........................
     CompareArray();
    section=sectionOut;

  }
}
//=========================================================================



//====== функции ==========================================================
//=========================================================================
// фунцция получения случайного байта - 001 , 010 , 100
//=========================================================================
byte RandomByte()
{
  byte tempByte=random(1,4);
  if(tempByte==3) tempByte=4;
return tempByte;
}
//=========================================================================
// фунцция очистки массива "задание"
//=========================================================================
void ClearAssignment()
{
  for(byte i=0;i<10;i++) { assignment[i]=0; };
}
//=========================================================================
// фунцция очистки массива "ответ"
//=========================================================================
void ClearReply()
{
  for(byte i=0;i<10;i++) { reply[i]=0; };
}
//=========================================================================
// фунцция вывода байта на СД "задание"
//=========================================================================
void OutByteAssignment(byte _n)
{
  switch (_n)
  {
    case 0 :                    // для выключения всех трёх СД_задание
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 1 :
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 2 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 4 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,HIGH);
      break;
    }
        case 7 :                    // для включения всех трёх СД_задание
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,HIGH);
      break;
    }
  }
}
//=========================================================================
// фунцция вывода байта на СД "жизнь"
//=========================================================================
void OutByteLive(byte _n)
{
  switch (_n)
  {
    case 0 :                    // для выключения всех трёх СД_жизнь
    {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 1 :
    {
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 2 :
    {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 4 :
    {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,HIGH);
      break;
    }
        case 7 :                    // для включения всех трёх СД_жизнь
    {
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,HIGH);
      break;
    }
  }
}
//=========================================================================
// функция сравнения массивов "задание" и "ответ"
//=========================================================================
void CompareArray()

{
	boolean error=0;
	
	for(byte i=0;i<10;i++) 
	{ 
		if(assignment[i] != reply[i])
		{
		error=1;
		break;
		}
	}
		if (error)
		{
		liveCurrent--;
		}
		else 
		{
		levelCurrent++;
		}
}
//=========================================================================

Хорошо) На дежурство?) 

аха :)

для поломки головы на досуге - напиши код функции случайного вкл СД_зад по алгоритму 2-ва из 3-ёх ....
какие комбинации возможны ? сколько их ? и код.....
если есть желание конешшшна :)

Есть простое решение) Ну по крайней мере я так думаю.. У нас функция рандом выдает значения 1, 2, 4. Потом с помощью функции  OutByteAssignment , если мы передали значение 1, загорается 1-ый светодиод.  Если 2: второй и т.д Вот эту функцию и надо переписать. Если передается в нее число 1, то загораются СД1 и СД2. Если передается 2: загораются СД1 и СД3. А если передали 4: СД2 и СД3. Вот вроде бы и все) Т.к из 3х сведодиодов можно сделать только 3 комбинации по 2а СД.

1) СД1 и СД2
2) СД1 и СД3
3) СД2 и СД3

Если конечно я правильно понял задачу)) 

//=========================================================================
// фунцция вывода байта на СД "задание"
//=========================================================================
void OutByteAssignment(byte _n)
{
  switch (_n)
  {
    case 0 :                    // для выключения всех трёх СД_задание
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 1 :
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 2 :
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,HIGH);
      break;
    }
    case 4 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,HIGH);
      break;
    }
        case 7 :                    // для включения всех трёх СД_задание
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,HIGH);
      break;
    }
  }
}
//=========================================================================

да :)

#define DEBUG 1

#define knopka1 2
#define knopka2 3
#define knopka3 4
  #define ledLive1 10
  #define ledLive2 9
  #define ledLive3 8
#define ledAssignment1 5
#define ledAssignment2 6
#define ledAssignment3 7
 #define ledBlockButtons 11
byte levelCurrent=1;
byte levelMax=10;
byte liveCurrent=3;
 enum SECTION{sectionOut,sectionIn,sectionResult};
 SECTION section=sectionOut;
unsigned long oldMillis;
 byte assignment[10];
 byte reply[10];
 byte countKnopka;
//=========================================================================
void setup()
{
#ifdef DEBUG
  Serial.begin (9600);
#endif
  pinMode (knopka1,INPUT);
  digitalWrite(knopka1,HIGH);
  pinMode (knopka2 ,INPUT);
  digitalWrite(knopka2,HIGH);
  pinMode (knopka3,INPUT);
  digitalWrite(knopka3,HIGH);
    pinMode (ledAssignment1,OUTPUT);
    pinMode (ledAssignment2,OUTPUT);
    pinMode (ledAssignment3,OUTPUT);
    OutByteAssignment(0);
  pinMode (ledLive1,OUTPUT);
  pinMode (ledLive2,OUTPUT);
  pinMode (ledLive3,OUTPUT);
  OutByteLive(0);
    pinMode (ledBlockButtons,OUTPUT);
    digitalWrite(ledBlockButtons,LOW);
  randomSeed (analogRead(0));
   oldMillis=millis();
}
//=========================================================================
void loop()
{
// sectionOut
  if(section==sectionOut)
  {
    ClearAssignment();   // очистить массив
    fillAssignment();    // заполнить массив
    showLive();          // показать жизни
    showAssignment();    // показать задание
    digitalWrite(ledBlockButtons,HIGH);   // вкл подсветки блока кнопок
#ifdef DEBUG
    controlAssignment(); // функция просмотра задания
#endif
    ClearReply();        // очистить массив
    countKnopka=0;       // обнулить колво нажатий
    section=sectionIn;   // смена флага секции
    oldMillis=millis();  // вкл секундомер
  }
// sectionIn
  if(section==sectionIn)
  {
    if((millis()-oldMillis)<(2000+levelCurrent*500))
    {
      if(countKnopka<10)
      {
        if(!digitalRead(knopka1))
        {
          delay(50);
          reply[countKnopka]=1;
          countKnopka++;
        }
        if(!digitalRead(knopka2))
        {
          delay(50);
          reply[countKnopka]=2;
          countKnopka++;
        }
        if(!digitalRead(knopka3))
        {
          delay(50);
          reply[countKnopka]=4;
          countKnopka++;
        }
      }
    }
    else
    {
      digitalWrite(ledBlockButtons,LOW);   // выкл подсветки блока кнопок
#ifdef DEBUG
      Serial.println("...allotted time has expired !");
#endif
      section=sectionResult;   // смена флага секции
    }
  }
// sectionResult
  if(section==sectionResult)
  {
#ifdef DEBUG
  controlReply();         // функция просмотра ответов
#endif
    CompareArray();       // сравнить массивы, принять решение
    // showResult();      // ещё не написана :)
    section=sectionOut;   // смена флага секции
  }
}
//=========================================================================



//====== функции ==========================================================
//=========================================================================
// фунцция получения случайного байта - 001 , 010 , 100
//=========================================================================
byte RandomByte()
{
  byte tempByte=random(1,4);
  if(tempByte==3) tempByte=4;
return tempByte;
}
//=========================================================================
// фунцция очистки массива "задание"
//=========================================================================
void ClearAssignment()
{
  for(byte i=0;i<10;i++) { assignment[i]=0; };
}
//=========================================================================
// фунцция очистки массива "ответ"
//=========================================================================
void ClearReply()
{
  for(byte i=0;i<10;i++) { reply[i]=0; };
}
//=========================================================================
// фунцция вывода байта на СД "задание"
//=========================================================================
void OutByteAssignment(byte _n)
{
  switch (_n)
  {
    case 0 :                    // для выключения всех трёх СД_задание
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 1 :
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 2 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 4 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,HIGH);
      break;
    }
        case 7 :                    // для включения всех трёх СД_задание
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,HIGH);
      break;
    }
  }
}
//=========================================================================
// фунцция вывода байта на СД "жизнь"
//=========================================================================
void OutByteLive(byte _n)
{
  switch (_n)
  {
    case 0 :                    // для выключения всех трёх СД_жизнь
    {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 1 :
    {
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 2 :
    {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 4 :
    {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,HIGH);
      break;
    }
        case 7 :                    // для включения всех трёх СД_жизнь
    {
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,HIGH);
      break;
    }
  }
}
//=========================================================================
// функция сравнения массивов "задание" и "ответ"
//=========================================================================
void CompareArray()
{
  boolean error=0;
  for(byte i=0;i<10;i++) 
  { 
    if(assignment[i]!=reply[i])
    {
      error=1;
      break;
    }
  }
  if (error)
  {
    liveCurrent--;
  }
  else 
  {
    levelCurrent++;
  }
}
//=========================================================================
// функция заполнения массива "задание"
//=========================================================================
void fillAssignment()
{
  for(byte i=0;i<levelCurrent;i++)
  {
    if(i==0) assignment[0]=RandomByte();
    if(i>0)
    {
    byte tempByte=RandomByte();
    while(assignment[i-1]==tempByte)
    {
      tempByte=RandomByte();
    }
    assignment[i]=tempByte;
    }
  }
}
//=========================================================================
// функция показать жизни
//=========================================================================
void showLive()
{
  for(int i=0;i<5;i++)
  {
    OutByteLive(7);
    delay(100);
    OutByteLive(0);
    delay(100);
  }
  OutByteLive(liveCurrent);
  delay(1000);
  OutByteLive(0);
  delay(1000);
}
//=========================================================================
// функция показать задание
//=========================================================================
void showAssignment()
{
  OutByteAssignment(7);
  delay(1000);
  OutByteAssignment(0);
  delay(1000);
  byte n=0;                            // начало миганий задания
  while((assignment[n]!=0)&&(n<10))
  {
    OutByteAssignment(assignment[n]);  // вкл случСД
    delay(500);                        // пауза
    OutByteAssignment(0);              // выкл случСД
    delay(500);                        // пауза
    n++;
  }                                    // окончание миганий задания
  delay(500);
  OutByteAssignment(7);
  delay(500);
  OutByteAssignment(0);
  delay(500);
}
//=========================================================================
// функция просмотра задания
//=========================================================================
void controlAssignment()
{
  Serial.print(" level = ");
  Serial.println(levelCurrent);
  for(byte i=0;i<10;i++)
  {
    Serial.print(assignment[i]);
    Serial.print(" ");
  }
  Serial.println("");
  Serial.println(" GO ! Push button !!!");
}
//=========================================================================
// функция просмотра ответов
//=========================================================================
void controlReply()
{
  for(byte i=0;i<10;i++)
  {
    Serial.print(reply[i]);
    Serial.print(" ");
  }
  Serial.println("");
  Serial.println("************************");
}
//=========================================================================

чтобы секция реализаций функций не маячила в основном тексте - их можно перенести в отдельный файл и подключить этот файл #include ........

убрал диспетчер секций.... хватит и флага boolean wait;

#define DEBUG 1

#define knopka1 2
#define knopka2 3
#define knopka3 4
  #define ledLive1 10
  #define ledLive2 9
  #define ledLive3 8
#define ledAssignment1 5
#define ledAssignment2 6
#define ledAssignment3 7
 #define ledBlockButtons 11
byte levelCurrent=1;
byte levelMax=10;
byte liveCurrent=3;
// enum SECTION{sectionOut,sectionIn,sectionResult};
// SECTION section=sectionOut;
boolean wait=1;
unsigned long oldMillis;
 byte assignment[10];
 byte reply[10];
 byte countKnopka;
//=========================================================================
void setup()
{
#ifdef DEBUG
  Serial.begin (9600);
#endif
  pinMode (knopka1,INPUT);
  digitalWrite(knopka1,HIGH);
  pinMode (knopka2 ,INPUT);
  digitalWrite(knopka2,HIGH);
  pinMode (knopka3,INPUT);
  digitalWrite(knopka3,HIGH);
    pinMode (ledAssignment1,OUTPUT);
    pinMode (ledAssignment2,OUTPUT);
    pinMode (ledAssignment3,OUTPUT);
    OutByteAssignment(0);
  pinMode (ledLive1,OUTPUT);
  pinMode (ledLive2,OUTPUT);
  pinMode (ledLive3,OUTPUT);
  OutByteLive(0);
    pinMode (ledBlockButtons,OUTPUT);
    digitalWrite(ledBlockButtons,LOW);
  randomSeed (analogRead(0));
   oldMillis=millis();
}
//=========================================================================
void loop()
{
// sectionOut
//  if(section==sectionOut)
//  {
  ClearAssignment();   // очистить массив
  fillAssignment();    // заполнить массив
  showLive();          // показать жизни
  showAssignment();    // показать задание
  digitalWrite(ledBlockButtons,HIGH);   // вкл подсветки блока кнопок
#ifdef DEBUG
  controlAssignment(); // функция просмотра задания
#endif
  ClearReply();        // очистить массив
  countKnopka=0;       // обнулить колво нажатий
//  section=sectionIn;   // смена флага секции
  oldMillis=millis();  // вкл секундомер
//  }
// sectionIn
//  if(section==sectionIn)
  if(wait)
  {
    if((millis()-oldMillis)<(2000+levelCurrent*500))
    {
      if(countKnopka<10)
      {
        if(!digitalRead(knopka1))
        {
          delay(50);
          reply[countKnopka]=1;
          countKnopka++;
        }
        if(!digitalRead(knopka2))
        {
          delay(50);
          reply[countKnopka]=2;
          countKnopka++;
        }
        if(!digitalRead(knopka3))
        {
          delay(50);
          reply[countKnopka]=4;
          countKnopka++;
        }
      }
    }
    else
    {
      digitalWrite(ledBlockButtons,LOW);   // выкл подсветки блока кнопок
#ifdef DEBUG
      Serial.println("...allotted time has expired !");
#endif
//      section=sectionResult;   // смена флага секции
    wait=0;
    }
  }
// sectionResult
//  if(section==sectionResult)
//  {
#ifdef DEBUG
  controlReply();       // функция просмотра ответов
#endif
  CompareArray();       // сравнить массивы, принять решение
  showResult();         // ещё не написана :)
//  section=sectionOut;   // смена флага секции
}
//=========================================================================



//====== функции ==========================================================
//=========================================================================
// фунцция получения случайного байта - 001 , 010 , 100
//=========================================================================
byte RandomByte()
{
  byte tempByte=random(1,4);
  if(tempByte==3) tempByte=4;
return tempByte;
}
//=========================================================================
// фунцция очистки массива "задание"
//=========================================================================
void ClearAssignment()
{
  for(byte i=0;i<10;i++) { assignment[i]=0; };
}
//=========================================================================
// фунцция очистки массива "ответ"
//=========================================================================
void ClearReply()
{
  for(byte i=0;i<10;i++) { reply[i]=0; };
}
//=========================================================================
// фунцция вывода байта на СД "задание"
//=========================================================================
void OutByteAssignment(byte _n)
{
  switch (_n)
  {
    case 0 :                    // для выключения всех трёх СД_задание
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 1 :
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 2 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 4 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,HIGH);
      break;
    }
        case 7 :                    // для включения всех трёх СД_задание
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,HIGH);
      break;
    }
  }
}
//=========================================================================
// фунцция вывода байта на СД "жизнь"
//=========================================================================
void OutByteLive(byte _n)
{
  switch (_n)
  {
    case 0 :                    // для выключения всех трёх СД_жизнь
    {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 1 :
    {
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 2 :
    {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 4 :
    {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,HIGH);
      break;
    }
        case 7 :                    // для включения всех трёх СД_жизнь
    {
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,HIGH);
      break;
    }
  }
}
//=========================================================================
// функция сравнения массивов "задание" и "ответ"
//=========================================================================
void CompareArray()
{
  boolean error=0;
  for(byte i=0;i<10;i++) 
  { 
    if(assignment[i]!=reply[i])
    {
      error=1;
      break;
    }
  }
  if (error)
  {
    liveCurrent--;
  }
  else 
  {
    levelCurrent++;
  }
}
//=========================================================================
// функция заполнения массива "задание"
//=========================================================================
void fillAssignment()
{
  for(byte i=0;i<levelCurrent;i++)
  {
    if(i==0) assignment[0]=RandomByte();
    if(i>0)
    {
    byte tempByte=RandomByte();
    while(assignment[i-1]==tempByte)
    {
      tempByte=RandomByte();
    }
    assignment[i]=tempByte;
    }
  }
}
//=========================================================================
// функция показать жизни
//=========================================================================
void showLive()
{
  for(int i=0;i<5;i++)
  {
    OutByteLive(7);
    delay(100);
    OutByteLive(0);
    delay(100);
  }
  OutByteLive(liveCurrent);
  delay(1000);
  OutByteLive(0);
  delay(1000);
}
//=========================================================================
// функция показать задание
//=========================================================================
void showAssignment()
{
  OutByteAssignment(7);
  delay(1000);
  OutByteAssignment(0);
  delay(1000);
  byte n=0;                            // начало миганий задания
  while((assignment[n]!=0)&&(n<10))
  {
    OutByteAssignment(assignment[n]);  // вкл случСД
    delay(500);                        // пауза
    OutByteAssignment(0);              // выкл случСД
    delay(500);                        // пауза
    n++;
  }                                    // окончание миганий задания
  delay(500);
  OutByteAssignment(7);
  delay(500);
  OutByteAssignment(0);
  delay(500);
}
//=========================================================================
// функция просмотра задания
//=========================================================================
void controlAssignment()
{
  Serial.print(" level = ");
  Serial.println(levelCurrent);
  for(byte i=0;i<10;i++)
  {
    Serial.print(assignment[i]);
    Serial.print(" ");
  }
  Serial.println("");
  Serial.println(" GO ! Push button !!!");
}
//=========================================================================
// функция просмотра ответов
//=========================================================================
void controlReply()
{
  for(byte i=0;i<10;i++)
  {
    Serial.print(reply[i]);
    Serial.print(" ");
  }
  Serial.println("");
  Serial.println("************************");
}
//=========================================================================
// функция просмотра ответов
//=========================================================================
void showResult()
{

}
//=========================================================================

#define DEBUG 1

#define knopka1 2
#define knopka2 3
#define knopka3 4
  #define ledLive1 10
  #define ledLive2 9
  #define ledLive3 8
#define ledAssignment1 5
#define ledAssignment2 6
#define ledAssignment3 7
 #define ledBlockButtons 11
byte levelCurrent=1;
byte levelMax=10;
byte liveCurrent=3;
boolean wait=1;
unsigned long oldMillis;
 byte assignment[10];
 byte reply[10];
 byte countKnopka;
//=========================================================================
void setup()
{
#ifdef DEBUG
  Serial.begin (9600);
#endif
  pinMode (knopka1,INPUT);
  digitalWrite(knopka1,HIGH);
  pinMode (knopka2 ,INPUT);
  digitalWrite(knopka2,HIGH);
  pinMode (knopka3,INPUT);
  digitalWrite(knopka3,HIGH);
    pinMode (ledAssignment1,OUTPUT);
    pinMode (ledAssignment2,OUTPUT);
    pinMode (ledAssignment3,OUTPUT);
    OutByteAssignment(0);
  pinMode (ledLive1,OUTPUT);
  pinMode (ledLive2,OUTPUT);
  pinMode (ledLive3,OUTPUT);
  OutByteLive(0);
    pinMode (ledBlockButtons,OUTPUT);
    digitalWrite(ledBlockButtons,LOW);
  randomSeed (analogRead(0));
   oldMillis=millis();
}
//=========================================================================
void loop()
{
// sectionOut *************************************************
  ClearAssignment();   // очистить массив
  fillAssignment();    // заполнить массив
  showLive();          // показать жизни
  showAssignment();    // показать задание
  digitalWrite(ledBlockButtons,HIGH);   // вкл подсветки блока кнопок
#ifdef DEBUG
  controlAssignment(); // функция просмотра задания
#endif
  ClearReply();        // очистить массив
  countKnopka=0;       // обнулить колво нажатий
  oldMillis=millis();  // вкл секундомер
// sectionIn *************************************************
  if(wait)
  {
    if((millis()-oldMillis)<(2000+levelCurrent*500))
    {
      if(countKnopka<10)
      {
        if(!digitalRead(knopka1))
        {
          delay(50);
          reply[countKnopka]=1;
          countKnopka++;
        }
        if(!digitalRead(knopka2))
        {
          delay(50);
          reply[countKnopka]=2;
          countKnopka++;
        }
        if(!digitalRead(knopka3))
        {
          delay(50);
          reply[countKnopka]=4;
          countKnopka++;
        }
      }
    }
    else
    {
      digitalWrite(ledBlockButtons,LOW);   // выкл подсветки блока кнопок
#ifdef DEBUG
      Serial.println("...allotted time has expired !");
#endif
    wait=0;
    }
  }
// sectionResult *************************************************
#ifdef DEBUG
  controlReply();       // функция просмотра ответов
#endif
  CompareArray();       // сравнить массивы, принять решение
  showResult();         // ещё не написана :)
  wait=1;
}
//=========================================================================



//====== функции ==========================================================
//=========================================================================
// фунцция получения случайного байта - 001 , 010 , 100
//=========================================================================
byte RandomByte()
{
  byte tempByte=random(1,4);
  if(tempByte==3) tempByte=4;
return tempByte;
}
//=========================================================================
// фунцция очистки массива "задание"
//=========================================================================
void ClearAssignment()
{
  for(byte i=0;i<10;i++) { assignment[i]=0; };
}
//=========================================================================
// фунцция очистки массива "ответ"
//=========================================================================
void ClearReply()
{
  for(byte i=0;i<10;i++) { reply[i]=0; };
}
//=========================================================================
// фунцция вывода байта на СД "задание"
//=========================================================================
void OutByteAssignment(byte _n)
{
  switch (_n)
  {
    case 0 :                    // для выключения всех трёх СД_задание
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 1 :
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 2 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 4 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,HIGH);
      break;
    }
        case 7 :                    // для включения всех трёх СД_задание
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,HIGH);
      break;
    }
  }
}
//=========================================================================
// фунцция вывода байта на СД "жизнь"
//=========================================================================
void OutByteLive(byte _n)
{
  switch (_n)
  {
    case 0 :                    // для выключения всех трёх СД_жизнь
    {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 1 :
    {
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 2 :
    {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 4 :
    {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,HIGH);
      break;
    }
        case 7 :                    // для включения всех трёх СД_жизнь
    {
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,HIGH);
      break;
    }
  }
}
//=========================================================================
// функция сравнения массивов "задание" и "ответ"
//=========================================================================
void CompareArray()
{
  boolean error=0;
  for(byte i=0;i<10;i++) 
  { 
    if(assignment[i]!=reply[i])
    {
      error=1;
      break;
    }
  }
  if (error)
  {
    liveCurrent--;
  }
  else 
  {
    levelCurrent++;
  }
}
//=========================================================================
// функция заполнения массива "задание"
//=========================================================================
void fillAssignment()
{
  for(byte i=0;i<levelCurrent;i++)
  {
    if(i==0) assignment[0]=RandomByte();
    if(i>0)
    {
    byte tempByte=RandomByte();
    while(assignment[i-1]==tempByte)
    {
      tempByte=RandomByte();
    }
    assignment[i]=tempByte;
    }
  }
}
//=========================================================================
// функция показать жизни
//=========================================================================
void showLive()
{
  for(int i=0;i<5;i++)
  {
    OutByteLive(7);
    delay(100);
    OutByteLive(0);
    delay(100);
  }
  OutByteLive(liveCurrent);
  delay(1000);
  OutByteLive(0);
  delay(1000);
}
//=========================================================================
// функция показать задание
//=========================================================================
void showAssignment()
{
  OutByteAssignment(7);
  delay(1000);
  OutByteAssignment(0);
  delay(1000);
  byte n=0;                            // начало миганий задания
  while((assignment[n]!=0)&&(n<10))
  {
    OutByteAssignment(assignment[n]);  // вкл случСД
    delay(500);                        // пауза
    OutByteAssignment(0);              // выкл случСД
    delay(500);                        // пауза
    n++;
  }                                    // окончание миганий задания
  delay(500);
  OutByteAssignment(7);
  delay(500);
  OutByteAssignment(0);
  delay(500);
}
//=========================================================================
// функция просмотра задания
//=========================================================================
void controlAssignment()
{
  Serial.print(" level = ");
  Serial.println(levelCurrent);
  for(byte i=0;i<10;i++)
  {
    Serial.print(assignment[i]);
    Serial.print(" ");
  }
  Serial.println("");
  Serial.println(" GO ! Push button !!!");
}
//=========================================================================
// функция просмотра ответов
//=========================================================================
void controlReply()
{
  for(byte i=0;i<10;i++)
  {
    Serial.print(reply[i]);
    Serial.print(" ");
  }
  Serial.println("");
  Serial.println("************************");
}
//=========================================================================
// функция просмотра ответов
//=========================================================================
void showResult()
{

}
//=========================================================================

А чем диспетчер помешал? Все равно не работает, и не считывает в Serial нажатие кнопок..

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

состояние проекта какое ? может уже всё решили-построили ? мне макетку строить для проверки ? :)

Я собирал. Перепроверял... Не получается никак. Самое интересное, когда включаешь serial, он выдает что надо нажимать кнопку. Но когда нажал кнопку, ничего не выходит .Что нажал и все остальное. И еще при нажатии кнопки, как буд-то кз происходит. И ардуино reset. Не знаю от чего может быть( 

при посадке пинов кнопок на землю - в сериал получал 1111111111 или 222222222222222 или 444444444444444
утром соберу макетку - посмотрю ( виртуальное обсуждение закончилось )

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

а кнопки как подключены ? поточнее !

когда включаешь serial

имеешь ввиду раскоммент дебуга ? или что ?

Когда загрузил скетч, нажимаешь на кнопку( не помню как называается), чтобы смотреть что творится на порту у тебя. Что выдает serial в окне. Т.е сначала выводит уровень, массив, говорит жми кнопку и все такое) Ну хорошо.. А то я не могу разобраться.. Кнопка подсоеденена так:

С земли на кнопку, с кнопки на +5В. Между кнопкой и 5В - подключен пин

С земли на кнопку, с кнопки на +5В. Между кнопкой и 5В - подключен пин

с земли на кнопку, с кнопки на пин !!!! всё !
теневое ( тибе незаметное подключение ) - ( с кнопки и пина ) на резистор внутренней подтяжки МК , с него на VCC.......

с земли на кнопку, с кнопки на пин !!!! всё ! больше никаких подключений !

Вот блин... точно... Сейчас.. Вот глупая бошка(( 

Я думал на +5 надо((( 

уже 6 страниц ! сообщений > 250 ! это рекорд !
...где-то выше моя писал про подключение кнопок по двум вариантам. и сказал что твой вариант №2 ! нет ?
....перечитай, Гюльчатай :)-

Попробовал старый код с диспетчером, выдал :

 level = 1
2 0 0 0 0 0 0 0 0 0 
 GO ! Push button !!!
...allotted time has expired !
2 2 2 2 2 2 2 2 0 0 
************************
 level = 1
1 0 0 0 0 0 0 0 0 0 
 GO ! Push button !!!
...allotted time has expired !
1 1 1 1 1 1 1 1 1 1 
************************
 level = 1
2 0 0 0 0 0 0 0 0 0 
 GO ! Push button !!!
...allotted time has expired !
2 2 2 2 2 2 2 2 2 2 
************************
 level = 1
2 0 0 0 0 0 0 0 0 0 
 GO ! Push button !!!
...allotted time has expired !
0 0 0 0 0 0 0 0 0 0 
************************

А новый код, без диспетчера. Он там светодиод подсветки не отключает...

Т.е сначала выводит уровень, массив, говорит жми кнопку и все такое) Ну хорошо.. А то я не могу разобраться.. 
дык, спроси... ЁКЛМН !

 level = 1
2 0 0 0 0 0 0 0 0 0 
 GO ! Push button !!!
...allotted time has expired !
2 2 2 2 2 2 2 2 0 0 
************************
 level = 1
1 0 0 0 0 0 0 0 0 0 
 GO ! Push button !!!
...allotted time has expired !
1 1 1 1 1 1 1 1 1 1 
************************
 level = 1
2 0 0 0 0 0 0 0 0 0 
 GO ! Push button !!!
...allotted time has expired !
2 2 2 2 2 2 2 2 2 2 
************************
 level = 1
2 0 0 0 0 0 0 0 0 0 
 GO ! Push button !!!
...allotted time has expired !
0 0 0 0 0 0 0 0 0 0 
************************

дык, найди точку кода , когда его надо ВЫКЛ
....найду, изменю код - тибе легчеееееее станет ? чей код ? твой или мой ?
....мне думать за тибя ?

как в американских фильмах - " Гулиев ! Тряпка ! Соберись ........ мля ! Думай головой ! "

зря отключил автоматический перебор уровней :(
...но для теста ввода кнопок - самое ТО !

Хахах))) Я так и думал. Что что-то не то с отключением) Сейчас найду да и проверю. Но почему он выдает заполненый массив? Тут по-моему ошибка в том, что 1. массив сразу состоит из 10 элементов. 2. это из-за кнопки.. Что если долго держим, он считывает это все в массив.. Как с этим бороться? 

только коротким нажатием на кнопку !
.....в этом коде - только так.... вообще - надо отследить нажатие , а потом отпускание кнопки - давай про это попозжеееееееее ?

Хорошо)

кнопки переподключил ? какие результаты ? пардон...... результат ?

Я же показал. Выдает весь заполненный массив. Одними и теми же значениями. Изменил код. Сделал показатель жизни более понятнее. Было так,если 3 жизни - горит третий Сд, если 2 жизни, то горит только второй СД, если 1 жизнт-первый СД. сделал: если 2 жизни - горит первый и второй СД. если 3 жизни - то все сд. Теперь хорошо было бы сделать, чтобы жизни показывались постоянно

а крайний код сюда ? ( синхронизация базаров-разговоров ) - уже обсудили же :(
...утром соберу макетку

Спасибо)) 

#define DEBUG 1

#define knopka1 2
#define knopka2 3
#define knopka3 4
  #define ledLive1 10
  #define ledLive2 9
  #define ledLive3 8
#define ledAssignment1 5
#define ledAssignment2 6
#define ledAssignment3 7
 #define ledBlockButtons 11
byte levelCurrent=1;
byte levelMax=10;
byte liveCurrent=3;
 enum SECTION{sectionOut,sectionIn,sectionResult};
 SECTION section=sectionOut;
unsigned long oldMillis;
 byte assignment[10];
 byte reply[10];
 byte countKnopka;
//=========================================================================
void setup()
{
#ifdef DEBUG
  Serial.begin (9600);
#endif
  pinMode (knopka1,INPUT);
  digitalWrite(knopka1,HIGH);
  pinMode (knopka2 ,INPUT);
  digitalWrite(knopka2,HIGH);
  pinMode (knopka3,INPUT);
  digitalWrite(knopka3,HIGH);
    pinMode (ledAssignment1,OUTPUT);
    pinMode (ledAssignment2,OUTPUT);
    pinMode (ledAssignment3,OUTPUT);
    OutByteAssignment(0);
  pinMode (ledLive1,OUTPUT);
  pinMode (ledLive2,OUTPUT);
  pinMode (ledLive3,OUTPUT);
  OutByteLive(0);
    pinMode (ledBlockButtons,OUTPUT);
    digitalWrite(ledBlockButtons,LOW);
  randomSeed (analogRead(0));
   oldMillis=millis();
}
//=========================================================================
void loop()
{
// sectionOut
  if(section==sectionOut)
  {
    ClearAssignment();   // очистить массив
    fillAssignment();    // заполнить массив
    showLive();          // показать жизни
    showAssignment();    // показать задание
    digitalWrite(ledBlockButtons,HIGH);   // вкл подсветки блока кнопок
#ifdef DEBUG
    controlAssignment(); // функция просмотра задания
#endif
    ClearReply();        // очистить массив
    countKnopka=0;       // обнулить колво нажатий
    section=sectionIn;   // смена флага секции
    oldMillis=millis();  // вкл секундомер
  }
// sectionIn
  if(section==sectionIn)
  {
    if((millis()-oldMillis)<(2000+levelCurrent*500))
    {
      if(countKnopka<10)
      {
        if(!digitalRead(knopka1))
        {
          delay(50);
          reply[countKnopka]=1;
          countKnopka++;
        }
        if(!digitalRead(knopka2))
        {
          delay(50);
          reply[countKnopka]=2;
          countKnopka++;
        }
        if(!digitalRead(knopka3))
        {
          delay(50);
          reply[countKnopka]=4;
          countKnopka++;
        }
      }
    }
    else
    {
      digitalWrite(ledBlockButtons,LOW);   // выкл подсветки блока кнопок
#ifdef DEBUG
      Serial.println("...allotted time has expired !");
#endif
      section=sectionResult;   // смена флага секции
    }
  }
// sectionResult
  if(section==sectionResult)
  {
#ifdef DEBUG
  controlReply();         // функция просмотра ответов
#endif
    CompareArray();       // сравнить массивы, принять решение
    // showResult();      // ещё не написана :)
    section=sectionOut;   // смена флага секции
  }
}
//=========================================================================



//====== функции ==========================================================
//=========================================================================
// фунцция получения случайного байта - 001 , 010 , 100
//=========================================================================
byte RandomByte()
{
  byte tempByte=random(1,4);
  if(tempByte==3) tempByte=4;
return tempByte;
}
//=========================================================================
// фунцция очистки массива "задание"
//=========================================================================
void ClearAssignment()
{
  for(byte i=0;i<10;i++) { assignment[i]=0; };
}
//=========================================================================
// фунцция очистки массива "ответ"
//=========================================================================
void ClearReply()
{
  for(byte i=0;i<10;i++) { reply[i]=0; };
}
//=========================================================================
// фунцция вывода байта на СД "задание"
//=========================================================================
void OutByteAssignment(byte _n)
{
  switch (_n)
  {
    case 0 :                    // для выключения всех трёх СД_задание
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 1 :
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 2 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,LOW);
      break;
    }
    case 4 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,HIGH);
      break;
    }
        case 7 :                    // для включения всех трёх СД_задание
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,HIGH);
      break;
    }
  }
}
//=========================================================================
// фунцция вывода байта на СД "жизнь"
//=========================================================================
void OutByteLive(byte _n)
{
  switch (_n)
  {
    case 0 :                    // для выключения всех трёх СД_жизнь
    {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 1 :
    {
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 2 :
    {
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,LOW);
      break;
    }
    case 4 :
    {
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,HIGH);
      break;
    }
        case 7 :                    // для включения всех трёх СД_жизнь
    {
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,HIGH);
      break;
    }
  }
}
//=========================================================================
// функция сравнения массивов "задание" и "ответ"
//=========================================================================
void CompareArray()
{
  boolean error=0;
  for(byte i=0;i<10;i++) 
  { 
    if(assignment[i]!=reply[i])
    {
      error=1;
      break;
    }
  }
  if (error)
  {
    liveCurrent--;
  }
  else 
  {
    levelCurrent++;
  }
}
//=========================================================================
// функция заполнения массива "задание"
//=========================================================================
void fillAssignment()
{
  for(byte i=0;i<levelCurrent;i++)
  {
    if(i==0) assignment[0]=RandomByte();
    if(i>0)
    {
    byte tempByte=RandomByte();
    while(assignment[i-1]==tempByte)
    {
      tempByte=RandomByte();
    }
    assignment[i]=tempByte;
    }
  }
}
//=========================================================================
// функция показать жизни
//=========================================================================
void showLive()
{
  for(int i=0;i<5;i++)
  {
    OutByteLive(7);
    delay(100);
    OutByteLive(0);
    delay(100);
  }
  OutByteLive(liveCurrent);
  delay(1000);
  OutByteLive(0);
  delay(1000);
}
//=========================================================================
// функция показать задание
//=========================================================================
void showAssignment()
{
  OutByteAssignment(7);
  delay(1000);
  OutByteAssignment(0);
  delay(1000);
  byte n=0;                            // начало миганий задания
  while((assignment[n]!=0)&&(n<10))
  {
    OutByteAssignment(assignment[n]);  // вкл случСД
    delay(500);                        // пауза
    OutByteAssignment(0);              // выкл случСД
    delay(500);                        // пауза
    n++;
  }                                    // окончание миганий задания
  delay(500);
  OutByteAssignment(7);
  delay(500);
  OutByteAssignment(0);
  delay(500);
}
//=========================================================================
// функция просмотра задания
//=========================================================================
void controlAssignment()
{
  Serial.print(" level = ");
  Serial.println(levelCurrent);
  for(byte i=0;i<10;i++)
  {
    Serial.print(assignment[i]);
    Serial.print(" ");
  }
  Serial.println("");
  Serial.println(" GO ! Push button !!!");
}
//=========================================================================
// функция просмотра ответов
//=========================================================================
void controlReply()
{
  for(byte i=0;i<10;i++)
  {
    Serial.print(reply[i]);
    Serial.print(" ");
  }
  Serial.println("");
  Serial.println("************************");
}
//=========================================================================

изменения - в чём ? где ?
 

#186-229

Чисто изменил отображение индикации

ОК ! хозяин - барин !
какую ошибку мине искать на макетке ?

почуял разницу ? искать где изменить в длинном коде или в конкретной функции изменить ?
:)

Да))) Намного удобнее )) 

Так, на макетке вроде все правильно) Косяк в том, что весь массив заполняет значениями((( 

влёт  - это увеличение задержки в строках #75, 81 , 87 до 100...200 - но это не правильно !

С земли на кнопку, с кнопки на +5В. Между кнопкой и 5В - подключен пин

нажатие кнопки при таком подключении - это КЗ по питанию :(
.....отсюда и перезагрузка происходила ( так можно и порт USB на компе-буке спалить )

Да это я тупанул..

Да это я тупанул..

Что посоветуешь сделать? А то при нажатии кнопки массив одними и теми же значениями заполняется((

#288 ( можно и 500 - для испытаний )
....и подумать надо

Ты написал что это не правильно... Есть же какие то варианты

это "неправильно" , а не неправильно :)
пробуй, ничё не сломается

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

попробуй так

      if(countKnopka<10)
      {
        if(!digitalRead(knopka1))
        {
          delay(75);
          while(!digitalRead(knopka1))
          reply[countKnopka]=1;
          countKnopka++;
        }

​в строке 5 ждём окончания дребезга
в строке 6 ждём отпускания кнопки

да

сейчас проверю