Arduino.ru

Да, особенно про "За и против"

50х50 - всё зависит от задачи... в каком-то коде это хорошо, в каком-то - хуже.....
...но надо знать про это и применять , в твоём проекте отображение байта на СД - это самое ТО.....

можно проект реализовать и на ATmega, а можно и на ATtiny, добавив последПараллРегистр для СД и параллПоследРегистр для кнопок......

Можно, но в этой задаче этого в принципе не требуется) Макетку собирал?) 

нет :( , День Варенья у соседа :) , пока только головой могу , руками уже нет :(

to kisoft :

// отображение порта D
// 0 - пин_0 - RX - низя изменять
// 1 - пин_1 - TX - низя изменять
// 2 - пин_2 - LED_live_0   для отображения колва жизней ( три бита )
// 3 - пин_3 - LED_live_1   для отображения колва жизней
// 4 - пин_4 - LED_live_2   для отображения колва жизней
// 5 - пин_5 - LED_level_0  для отображения уровня игры ( три бита )
// 6 - пин_6 - LED_level_1  для отображения уровня игры
// 7 - пин_7 - LED_level_2  для отображения уровня игры

// отображение порта B
// 0 - пин_8  Button_1
// 1 - пин_9  Button_2
// 2 - пин_10 Button_3
// 3 - 
// 4 - 
// 5 - 
// 6 - 
// 7 - 

byte liveCount;
byte levelCount;
//=========================================================
void setup()
{                
  DDRD=DDRD|B11111100;       // пины 0,1 - не изменяем
                               // пины 2,3,4,5,6,7 - режим OUTPUT
  PORTD=PORTD&B00000011;       // пины 0,1 - не изменяем
                               // пины 2,3,4,5,6,7 - устанавливаем на выходе LOW
  DDRB=B11111000;              // пины 0,1,2 - режим INPUT
                               // пины 2,3,4,5,6,7 - режим OUTPUT ( не используем пока )
  PORTB=B00000111;             // пины 0,1,2 - включаем внутреннюю подтяжку к VCC для кнопок
                               // пины 3,4,5,6,7 - устанавливаем на выходе LOW
}
//======= вывод байта жизнь на LED ========================
void OutLiveLED(byte _n)
{
  PORTD=(PORTD&B11100011)|(_n<<2);  // обнуляем биты 2,3,4 не затрагивая другие биты
                                    // на их место пишем байт жизней 
}
//======= вывод байта уровень на LED ======================
void OutLevelLED(byte _n)
{
  PORTD=(PORTD&B00011111)|(_n<<5);  // обнуляем биты 5,6,7 не затрагивая другие биты
                                    // на их место пишем байт уровня
}
//=========================================================
void loop()
{
  // жизнь = 3
  OutLiveLED(3);
  // уровень = 1
  OutLevelLED(1);
  // ................................
  // ................................
  // ................................
}
//=========================================================

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

Один не разберет, чем пахнут розы…
Другой из горьких трав добудет мед…
Кому-то мелочь дашь, навек запомнит…
Кому-то жизнь отдашь, а он и не поймет…

                                                                Омар Хайям

guliyev34 , моя всё знать не может ( да и никто ) - иногда приходится фею ( фея ) звать.....
:)-

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

Ого, я в шоке)))

ничего сложного там нет.... лучше за день научиться летать и долететь за 5 мин , чем иттить пешком три дня ! ( мульт )
если это курсовая - одно, зафанател - терпи и учи.....

строки 30....33 в комментах ошибки.... там другие номера пинов надо указать :( 

SU-27-16, Если не вдаваться в подробности (поскольку я редко использую прямой доступ к регистрам), то есть только одна помарочка. Вот эта строка 38

PORTD=(PORTD&B11100011)|(_n<<2);

Она будет работать некорректо, если _n будет больше 8. Втупую исправить можно добавив перед этой командой строку:

  _n &= 0x7;

Но тогда если _n будет больше 8, оно не испортит биты порта, но всё равно будет работать криво.

Потому вопрос философский, что важнее.

спасибо,  быстрый спаситель :)
байты жизнь и уровень по задаче могут быть 0.....3 , для более - нужен int и мозги :)
по заданию нужно менять биты 2,3,4 и 5,6,7...

спасибо большое :)

Зафанател))))

а разницу увидел - через регистры зажигать СД или через много digitalWrite() ?

спрашивай.... у миня ПОКА время свободное - есть

Честно?) Я пока хочу разобраться с основами, вот игра, которую делаю, это и есть, так сказать введение во все это) Хочу сначала закончить это, а потом уже все остальное) Сейчас волнует только то, что если долго жму кнопку, результат не засчитывается(( 

А вот в этих сообщениях, не понял что стоит в левой и правой части, понял что коньюкция только)) 

PORTD&B11100011

ейчас волнует только то, что если долго жму кнопку, результат не засчитывается(( 
День Варенья помешал.....

PORTD&B11100011
побитно умножить состояние порта на константу
где в константе единицы - не изменят состояние этого бита ( 0 * 1 = 0 , 1 * 1 = 1 )
где в константе нули - приведёт к состоянию этих битов в 0 ( 0 * 0 = 0 , 0 * 1 = 0 )

...анализируй-думай

PORTD&B11100011
эта штука установит в ноль биты 2,3,4 и оставит биты 0,1,5,6,7 какими и были

Что значит буква "B"? Теперь, потом умножает порт (PORTD) на константу (11100011). Теперь, это же будет зависить от состяния порта? Так почему же изменит 234 и оставил 01567? Если состояние порта 1 , то состояние битов 0, 1, 2, 6, 7 останутся такими же как и были, а вот остальные биты станут равны 0. так как при умножении на 1&1=1, 1&0=0; Далее порт  = 0, тогда и все биты станут равны 0.. Я запутался.. 

1 ( десятиричное ) = B00000001 ( двоичное ) = 0x01 ( 16-ти)
....................................................
255 ( десятиричное ) = B11111111 ( дв0ичное ) = 0xFF ( 16-ти)

потом умножает порт (PORTD) на константу (11100011)
....умножаем по правилам ДВОИЧНОЙ логики ПОБИТНО ! 

Ну в принципе понятно.. Порт имеет 2 значения? 0 и 1. Что там с макеткой?(( 

с макеткой проблема :( , у миня все элементы в формфакторе SMD......
чего смог собрать - ардуино нано , три кнопки , два СД_задание ( но резистор 220 Om только один , т.е. одинСД )
время на ввод увеличил до 10 сек , чтобы не торопицца , заливал этот код

#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)<(10000+levelCurrent*500))
    {
      if(countKnopka<levelMax)
      {
        if(!digitalRead(knopka1))
        {
          digitalWrite(ledAssignment1,HIGH);    // визуализация нажатой кноки
          delay(50);
          while(!digitalRead(knopka1))
          { }
          reply[countKnopka]=1;
#ifdef DEBUG
    Serial.print("knopka1 = ");
    Serial.print(countKnopka);
#endif
          countKnopka++;
          digitalWrite(ledAssignment1,LOW);    // визуализация нажатой кноки
#ifdef DEBUG
    Serial.print(" >>> ");
    Serial.println(countKnopka);
#endif
        }
        if(!digitalRead(knopka2))
        {
          digitalWrite(ledAssignment2,HIGH);    // визуализация нажатой кноки
          delay(50);
          while(!digitalRead(knopka2))
          { }
          reply[countKnopka]=2;
#ifdef DEBUG
    Serial.print("knopka2 = ");
    Serial.print(countKnopka);
#endif
          countKnopka++;
          digitalWrite(ledAssignment2,LOW);    // визуализация нажатой кноки
#ifdef DEBUG
    Serial.print(" >>> ");
    Serial.println(countKnopka);
#endif
        }
        if(!digitalRead(knopka3))
        {
          digitalWrite(ledAssignment3,HIGH);    // визуализация нажатой кноки
          delay(50);
          while(!digitalRead(knopka3))
          { }
          reply[countKnopka]=4;
#ifdef DEBUG
    Serial.print("knopka3 = ");
    Serial.print(countKnopka);
#endif
          countKnopka++;
          digitalWrite(ledAssignment3,LOW);    // визуализация нажатой кноки
#ifdef DEBUG
    Serial.print(" >>> ");
    Serial.println(countKnopka);
#endif
        }
      }
    }
    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);
  Serial.print("live = ");
  Serial.println(liveCurrent);
  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("************************");
}
//=========================================================================

кнопка_3 глючит ( даже на слух она плохо щёлкает ) , но это пока не важно....
задание подсматривал в Сериале.....
...........в режиме ввода при нажатии кнопки включается СД соответствующий и горит пока нажата кнопка , при отпускании кнопки СД гаснет и записывается номер кнопки в массив

т.е. СД_задание подмигивают соответственно нажатой кнопке - работает , почему у тибя НЕТ ? или не так мой вопрос понял ?
....давай свой крайний код и вопросы

Ну в принципе понятно.. Порт имеет 2 значения? 0 и 1.

порт - это совокупность пинов... у UNO - порт D пины 0.....7 , порт B пины 8.....13 , порт C пины A0.....A5
состояние пина - да, 0 или 1 ( для входного пина ещё и Z-состояние )
состояние 8-ми битного порта - 0.......255
состояние порта и пина порта - разные вещи :)

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

dimax делает так :
А я уже не использую программные способы подавления дребезга :)  Раньше  не пользовался внешними прерываниями, а позже всё же оценил их удобства. Но в прерывании дребезг подавлять очень проблематично. Можно конечно, но как говорится "мне этой геморой не нужен" :) Но не всё так плохо, если подобрать конденсатор паралельно кнопке, то вероятность ложного срабатывания будет почти нулевой. При условии использования внутренней подтяжки я остановился на электролитах 1uF. С самой обычной кнопкой (а-ля ресет с морды компьютерного системника)  вероятность корректного срабатывания при тестировании была 100 раз из 100.

#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)<(5000+levelCurrent*500))
    {
      if(countKnopka<levelMax)
      {
        if(!digitalRead(knopka1))
        {
          digitalWrite(ledAssignment1,HIGH);    // визуализация нажатой кноки
          delay(50);
          while(!digitalRead(knopka1))
          { }
          reply[countKnopka]=1;
#ifdef DEBUG
    Serial.print("knopka1 = ");
    Serial.print(countKnopka);
#endif
          countKnopka++;
          digitalWrite(ledAssignment1,LOW);    // визуализация нажатой кноки
#ifdef DEBUG
    Serial.print(" >>> ");
    Serial.println(countKnopka);
#endif
        }
        if(!digitalRead(knopka2))
        {
          digitalWrite(ledAssignment2,HIGH);    // визуализация нажатой кноки
          delay(50);
          while(!digitalRead(knopka2))
          { }
          reply[countKnopka]=2;
#ifdef DEBUG
    Serial.print("knopka2 = ");
    Serial.print(countKnopka);
#endif
          countKnopka++;
          digitalWrite(ledAssignment2,LOW);    // визуализация нажатой кноки
#ifdef DEBUG
    Serial.print(" >>> ");
    Serial.println(countKnopka);
#endif
        }
        if(!digitalRead(knopka3))
        {
          digitalWrite(ledAssignment3,HIGH);    // визуализация нажатой кноки
          delay(50);
          while(!digitalRead(knopka3))
          { }
          reply[countKnopka]=4;
#ifdef DEBUG
    Serial.print("knopka3 = ");
    Serial.print(countKnopka);
#endif
          countKnopka++;
          digitalWrite(ledAssignment3,LOW);    // визуализация нажатой кноки
#ifdef DEBUG
    Serial.print(" >>> ");
    Serial.println(countKnopka);
#endif
        }
      }
    }
    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 3 :
    {
      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()
{
 
 OutByteLive(liveCurrent);
}
//=========================================================================
// функция показать задание
//=========================================================================
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);
  Serial.print("live = ");
  Serial.println(liveCurrent);
  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("************************");
}
//=========================================================================

Вот конечный код. Протестировал, работает классно) Долго или быстро жмешь на кнопки, пишет значения корректно, без нареканий. Светодиоды, при нажатие на кнопки, тоже загораются. Все работает правильно. Большое спасибо))) 

управление СД и чтение кнопок - переделывать на управление через порты будем ?
или уже всё устраивает ? проект закрыт ?
:)

Я добавлю еще 1 Сд, 1 кнопку, переделаю индикацию, чтобы сделать понятнее для игрока и скину сюда конечный вариант кода) На счет порта.. Я думаю что еще мы к этому вернемся, но в другом проекте))) Можете написать свой e-mail на всякий случай?) Меня Максим зовут кстати) 

roma1602@rambler.ru , Александр

Т.е просто подключить конденсатор параллельно кнопке и все?)) И не надо мучаться с дребезгом в коде?) 

К 375 посту познакомились) Приятно познакомится :)

:)

...а кондёры на кнопки - поставь

просмотрел сообщение - да, просто кондёры уменьшат код

Все, дописал код и доделал игру. Так как я делал эту игру чисто для того, чтобы научиться работать с ардуино, корпус делать не стал. Ну что получилось, то получилось) Строго не судите) (Желтый СД заменится на такой же как и все остальные, просто нет его под рукой пока)

Скетч:

#define DEBUG 1
#define knopka1 9
#define knopka2 10
#define knopka3 12
#define knopka4 11
  #define ledLive1 6
  #define ledLive2 7
  #define ledLive3 8
#define ledAssignment1 2
#define ledAssignment2 3
#define ledAssignment3 5
#define ledAssignment4 4
 #define ledBlockButtons 13
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 (knopka4,INPUT);
  digitalWrite(knopka4,HIGH);
    pinMode (ledAssignment1,OUTPUT);
    pinMode (ledAssignment2,OUTPUT);
    pinMode (ledAssignment3,OUTPUT);
    pinMode (ledAssignment4,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)<(5000+levelCurrent*500))
    {
      if(countKnopka<levelMax)
      {
        if(!digitalRead(knopka1))
        {
          digitalWrite(ledAssignment1,HIGH);    // визуализация нажатой кноки
          delay(50);
          while(!digitalRead(knopka1))
          { }
          reply[countKnopka]=1;
#ifdef DEBUG
    Serial.print("knopka1 = ");
    Serial.print(countKnopka);
#endif
          countKnopka++;
          digitalWrite(ledAssignment1,LOW);    // визуализация нажатой кноки
#ifdef DEBUG
    Serial.print(" >>> ");
    Serial.println(countKnopka);
#endif
        }
        if(!digitalRead(knopka2))
        {
          digitalWrite(ledAssignment2,HIGH);    // визуализация нажатой кноки
          delay(50);
          while(!digitalRead(knopka2))
          { }
          reply[countKnopka]=2;
#ifdef DEBUG
    Serial.print("knopka2 = ");
    Serial.print(countKnopka);
#endif
          countKnopka++;
          digitalWrite(ledAssignment2,LOW);    // визуализация нажатой кноки
#ifdef DEBUG
    Serial.print(" >>> ");
    Serial.println(countKnopka);
#endif
        }
        if(!digitalRead(knopka3))
        {
          digitalWrite(ledAssignment3,HIGH);    // визуализация нажатой кноки
          delay(50);
          while(!digitalRead(knopka3))
          { }
          reply[countKnopka]=3;
#ifdef DEBUG
    Serial.print("knopka3 = ");
    Serial.print(countKnopka);
#endif
          countKnopka++;
          digitalWrite(ledAssignment3,LOW);    // визуализация нажатой кноки
#ifdef DEBUG
    Serial.print(" >>> ");
    Serial.println(countKnopka);
#endif
        }
                if(!digitalRead(knopka4))
        {
          digitalWrite(ledAssignment4,HIGH);    // визуализация нажатой кноки
          delay(50);
          while(!digitalRead(knopka4))
          { }
          reply[countKnopka]=4;
#ifdef DEBUG
    Serial.print("knopka4 = ");
    Serial.print(countKnopka);
#endif
          countKnopka++;
          digitalWrite(ledAssignment4,LOW);    // визуализация нажатой кноки
#ifdef DEBUG
    Serial.print(" >>> ");
    Serial.println(countKnopka);
#endif
        }
      }
    }
    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,5);
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);
      digitalWrite(ledAssignment4,LOW);
      break;
    }
    case 1 :
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,LOW);
      digitalWrite(ledAssignment4,LOW);
      break;
    }
    case 2 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,LOW);
      digitalWrite(ledAssignment4,LOW);
      break;
    }
    case 3 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,HIGH);
      digitalWrite(ledAssignment4,LOW);
      break;
    }    
    case 4 :
    {
      digitalWrite(ledAssignment1,LOW);
      digitalWrite(ledAssignment2,LOW);
      digitalWrite(ledAssignment3,LOW);
      digitalWrite(ledAssignment4,HIGH);
      break;
    }
        case 7 :                    // для включения всех четырех СД_задание
    {
      digitalWrite(ledAssignment1,HIGH);
      digitalWrite(ledAssignment2,HIGH);
      digitalWrite(ledAssignment3,HIGH);
      digitalWrite(ledAssignment4,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 3 :
    {
      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++;
  }
  if (liveCurrent == 0)
  {
    Loss();
    levelCurrent = 1;
    liveCurrent = 3;
  }
  if (levelCurrent == 10)
  {
   Win();
   liveCurrent = 3;
   levelCurrent = 1;
  }
}
//=========================================================================
// функция заполнения массива "задание"
//=========================================================================
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()
{
 
 OutByteLive(liveCurrent);
}
//=========================================================================
// функция показать задание
//=========================================================================
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);
  Serial.print("live = ");
  Serial.println(liveCurrent);
  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 Win()
{
      for (int i=0 ; i < 3 ; i++)
      {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      delay(100);
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      delay (100);
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,LOW);
      delay(100);
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,HIGH);
      delay (100);
      }
      for (int i=0 ; i < 3 ; i++)
      {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      delay (200);
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,HIGH);
      delay (200);
      }

}
//=========================================================================
// фунцция оповещения игрока о проигрыше
//=========================================================================
void Loss()
{

      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      delay(100);
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      delay (100);
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,LOW);
      delay(100);
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,HIGH);
      delay (100);
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      delay(100);
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,HIGH);
      delay(100);     
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,HIGH);
      delay(100);      
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,HIGH);
      delay (100);      
      for (int i=0 ; i < 3 ; i++)
      {
      digitalWrite(ledLive1,LOW);
      digitalWrite(ledLive2,LOW);
      digitalWrite(ledLive3,LOW);
      delay (200);
      digitalWrite(ledLive1,HIGH);
      digitalWrite(ledLive2,HIGH);
      digitalWrite(ledLive3,HIGH);
      delay (200);
      }

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

Вот что получилось в итоге:

:) падравляю !!!!
а где резисторы для красных СД ?

void Loss() и void Win()  -  можно создать массив и в цикле выводить эти данные на СД - получится значительно короче

Я думал об этом)) Потом просто попробовал сделать так) Резисторы для красных находятся под ардуино) Очень долго пришлось повозиться с разводкой платы) Слишком не удобно распологались пины и элементы) Если что, могу показать как развел. Мало ли, может будут какие-нибудь замечания) 

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

Я уже с этим все) Проверял еще и эксперементировал с лазером) делал сигнализацию) Но там все просто) Еще сделал машинку на блютуз управлении. Она была на р/у. Поставил ардуино, запрограммировал. Написал приложение для телефона. Вот летает теперь) Сейчас вот хочу подключить к ней датчики. И сделать 2 режима работы. Один это чисто от телефона ездиет. Второй - езда с помощью датчиков (автоматический режим). Ручной режим сделал.. А вот автоматический не могу.. Точнее пока не допер как сделать переключение между ручным и автоматическим. Вот приходит на ардуино символ "М". Должен менять на автомат, если до этого было ручное. Или на ручное, если до этого было авто. Надо просто заняться этим) Сейчас времени не особо на это есть) И наверно через пару недель начну делать 3д Куб из светодиодов. Надо только понять какого размера хочу) 

А у тебя есть какие-нибудь проекты?) Хотелось бы посмотреть.. Может идея какая появится) 

Еще сделал машинку на блютуз управлении. Она была на р/у. Поставил ардуино, запрограммировал. Написал приложение для телефона.

можно подробнее ? в чём писал ? коды, тексты.... пробовал http://beta.appinventor.mit.edu/ , но версия onLine мне не нравится, а offLine не могу понять как скачать :(

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

Вот тут и делал.. App Invertor. http://appinventor.mit.edu/ Но тут не все можно реализовать. Например тачпад. Одновременное нажатие двух кнопок тоже не получилось сделать. Приложение, которое я написал, выглядет так

Вот эти кнопки по диагонали вставлены из-за того что 2 кнопки сразу не получается нажимать.. Например вот слева сверху. Машинка едет вперед и поворачивает влево одновременно. 

Все кнопки работают. И отправляют на ардуино определенный символ. И уже взависимости от символа выполняется команда. Я смотрел видеоурок как создавать приложение. Там все подробно рассказано и описано. http://www.youtube.com/watch?v=y2jAJ05s2EQ . А вот сама тема http://habrahabr.ru/post/252137/ 

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

Самая первая статья, которая поддалкнула на эту идею http://cxem.net/uprav/uprav46.php Вот еще эти посмотри: http://cxem.net/uprav/uprav43.php http://cxem.net/uprav/uprav57.php http://cxem.net/uprav/uprav34.php

Можешь помочь?

Проблема такая. Есть некое устройство, которое работает по командам от сотового телефона. Например приходит 'S', делается одно действие, а если приходит 'W', то другое. Так вот. Команды с телефона приходят разные. Как состоящие только из одного символа, так и из нескольких, например "Speed1". Переменная, в которую записываются команды, имеет тип данных char. char cmd; через Serial.println(cmd). Проверил как ардуино воспринимает приходящий в нее сигнал. Вот например 'S', она так и выдает. А вот например 'SA', он выдает сначала S, а потом отдельной строкой A. Но у меня в программе, именно под 'SA', заложенно какое-то действие. Если я посылаю команду 'SA' с телефона, ардуино выполняет (каким-то странным образом). А если в программе пишу 'SA', то не выполняет.  Я знаю что надо записать cmd как строку. Но:

- какое количество символов задать начальное? cmd[?];
- когда принимаю сигнал, надо проверять все в циклах? 
- как ардуино поймет сколько символов пришло, и какой длины будет cmd?

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

моя религия :
буфер обмена - один на всё
команда с устройства ( любого ) ардуине - #getADC,5,0/KS*
getADC- команда считать аналоговый пин
5 - номер пина
0 - не важно ( только для структуры приёма-передачи )
KS - контрольная сумма для контроля

ардуина отвечает - 
#valueADC,5,617/KS*

тибе такое же надо ?
код в состоянии зачатия ( может и не работать, косяки не все убрал )

#define pinIn1 A0
#define pinIn2 A1
#define pinIn3 A2
#define pinIn4 A3

#define maxPinsArrayLen (4)
char pinIn[maxPinsArrayLen] = {pinIn1, pinIn2, pinIn3, pinIn4};

#define maxBufferLen (33)
char serialBuffer[maxBufferLen];
#define maxUnitName (16)
char unitName[maxUnitName];
#define maxUnitNumber (3)
char unitNumber[maxUnitNumber];
#define maxUnitData (5)
char unitData[maxUnitData];
#define maxUnitCRC (5)
char unitCRC[maxUnitCRC];

const char startSymbol = '#';
const char separatorSymbol = ',';
const char crcSymbol = '/';
const char stopSymbol = '*';

// #COMMANDxxxxxxxxx,255,65535/65535*
//============================================================================================
void setup()
{
  Serial.begin(9600);
  for (byte i = 0; i < maxPinsArrayLen; i++)
  {
    pinMode(pinIn[i], INPUT);
  }
}
//============================================================================================
void loop()
{
  if (Serial.available() > 0)
  {
    if (startSymbol == Serial.read())
    {
      char *pSB = serialBuffer;
      char *pEndOfSB = serialBuffer + maxBufferLen;
      while (Serial.available() > 0)
      {
        char inByte = Serial.read();
        if (stopSymbol != inByte && pSB < pEndOfSB)
        {
          *pSB = inByte;
          pSB++;
        }
//        *pSB = inByte;
      }
    }
  printBuffer(serialBuffer);
  clearBuffer(serialBuffer);
  }
}
//============================================================================================
//============================================================================================
void printBuffer(char *pp_Buffer)
{
  for (byte i = 0; i < maxBufferLen; i++, pp_Buffer++)
  {
    Serial.print(*pp_Buffer);
  }
  Serial.println();
}
//============================================================================================
void clearBuffer(char *pp_Buffer)
{
  for (byte i = 0; i < maxBufferLen; i++)
  {
    *pp_Buffer = 0;
    pp_Buffer++;
  }
}
//============================================================================================

ссылки посмотрел... Спасибо ! уже начал делать кракозябры :)

Хаха)) Я уже сделал замер расстояния) И почти сделал автоматический режим. Но вот команду 'SA' (т.е двигататься назад и влево одновременно) ардуино не воспринимает.. Когда с телефона приходит, то работает все. Например есть функция. Получаю 'S' он едет назад. И получив следом 'A', он поворачивает влево. Поэтому с телефона получается делать это. И будет поворачивать назад и влево, до тех пор пока не придет символ 'T'(соответсвует отпусканию кнопки). А вот в программе записать не получается. Я так понимаю надо переменную которая принимает команду, сделать массивом символов (строкой).

Сейчас проблема в следующем.

Машинка на блютуз управлении. Приложении есть 11 кнопок. 4 из них это ехать вперед(W), назад(S), влево(A), вправо(D). другие 4, это вперед и влево (WA), вперед и вправо (WD), назад и влево(SA), назад и вправо(SD). и оставшиеся 3 это выбор скорости 100 - (I), 200 - (O), 255 - (P). Сейчас все работает как надо. Решил переделать приложение, и вместо такого выбора скорости, сделать чтобы скорость изменялась бегунком. Но не получается синхронизировать приложение и ардуино.  Ведь переменная одна в скетче, которая принимает команду. Имеет тип char. И например W,S,D,A она воспринимает как символы (как и должна). А вот цифры, она тоже переводит в символы. Короче надо разобраться с этим. Вот идея и проблема подробнее:

Есть Бегунок в приложении. Значения изменяются от 0(крайнее левое положение бегунка) до 100.(крайнее правое полжение бегунка). Вот например я могу попробовать с телефона отправить на ардуино строку "Speed100". Что будет означать: Speed - режим выбора скорости. 100 - поставить скорость на 100 (регулируется значение бегунком). Саму функцию написать могу. В программе 0 будет нулем, а 100 - это 255 (максимальное напряжение на выходе пина). Но вот ардуино должен сделать следующее. Получив эту строку, понять что это относится к скорости. Обратиться к функции и выставить скорость на 100(255). Как это сделать? Ведь переменная одна на все команды.. И на движение, и на выбор скорости.. 

посылать "Speed/100/" , в ардуине разобрать строку на две строки "Speed" и "100" по признаку-разделителю "/"
http://www.cplusplus.com/reference/cstring/strtok/
.....не переводи , внизу пример кода есть

Во, спасибо большое, буду разбираться) 

и ещё - строка в число
http://www.cplusplus.com/reference/cstdlib/atoi/?kw=atoi

или по русски :)
http://lord-n.narod.ru/download/books/walla/programming/Spr_po_C/14/strt...
http://lord-n.narod.ru/download/books/walla/programming/Spr_po_C/18/atoi...

Подскажите, пожалуйста, новичку. В этой теме на восемь страниц обсуждаются ошибки в простой программе. А нет ли для наборов (каких-то конкретных или всех вместе) какой-нибудь графической оболочки для этого самого IDE? Ведь существуют же Microsoft Robotics Studio или, скажем, LabVIEW. Например, для создания игр, к чему я причастен, есть Clickteam Fusion, Construct 2, GameMaker и прочее, которые позволяют делать всё то же, но через графический интерфейс даже без знания языка. Неужели тут всё руками без вариантов? Спасибо. Извините если может быть, не в тему.

Зачем? Язык Wiring до тупого прост. Програмирование визуальными блоками его только усложнит.