Arduino.ru

В 38 строке i используется как переменная цикла, а в строках 41 и 48 Вы её безбожно загаживаете.

Строки №№ 50-61 не исполняются никогда от слова совсем

Так и задумано?

А если хотите помощи, объясняйтесь толком - не экономьте буквы. Ваше "должны быть открытыми по переменной mag" понятно только Вам. Хотя, судя по коду, и Вам тоже непонятно.

переменная меняется, и нужно понять к какому диапазону значений онa принадлежит.

Понятнее не стало. Объясняйтесь толком.

А по первым моим двум фразам - все нормально? Так и задумано?

const int relPin = 4;//замок
const int relPin1 = 5;//вход
const int relPin2 = 6;//вых
const int relPin3 = 7;//пищ
int mag = 0;
int i =0;
int i1 = 0;
int i2 = 0;
int exi[10];
int bada[10];

void setup() {
pinMode(relPin, OUTPUT);
pinMode(relPin1, OUTPUT);
pinMode(relPin2, OUTPUT);
pinMode(relPin3, OUTPUT);
digitalWrite(relPin, HIGH);
digitalWrite(relPin1, HIGH);
digitalWrite(relPin2, HIGH);
digitalWrite(relPin3, HIGH);
Serial.begin(9600);
}

void loop() {

           int mag = analogRead(0)/10; // чтение переменной
            if (mag > 15 && mag < 25){ //исходя из положения заполняю возможные конечные значения
              exi[0] = 46;exi[1] = 47;exi[2] = 48;exi[3] = 49;exi[4] = 50;exi[5] = 51;exi[6] = 52;exi[6] = 53;exi[7] = 54;exi[8] = 55;exi[9] = 55; // тут правельные
             bada[0]= 81;bada[1]= 82;bada[2]= 83;bada[3]= 84;bada[4]= 85;bada[5]= 86;bada[6]= 87;bada[7]= 88;bada[8]= 89;bada[9]= 90; // тут не правельные
               }
            else if (mag > 45 && mag < 55){
              exi[0]= 81;exi[1]= 82;exi[2]= 83;exi[3]= 84;exi[4]= 85;exi[5]= 86;exi[6]= 87;exi[7]= 88;exi[8]= 89;exi[9]= 90; // правельные 
              bada[0]= 15;bada[1]= 16;bada[2]= 17;bada[3]= 18;bada[4]= 19;bada[5]= 20;bada[6]= 21;bada[7]= 22;bada[8]= 23;bada[9]= 24; // не правельные
              }
            else{
              exi[0]= 15;exi[1]= 16;exi[2]= 17;exi[3]= 18;exi[4]= 19;exi[5]= 20;exi[6]= 21;exi[7]= 22;exi[8]= 23;exi[9]= 24; // правельные 
              bada[0] = 46;bada[1] = 47;bada[2] = 48;bada[3] = 49;bada[4] = 50;bada[5] = 51;bada[6] = 52;bada[7] = 53;bada[8] = 54;bada[9] = 55; // не правельные
              }              
              i = 0;             
              while (i < 20){           // считаю до 20 раз
                mag = analogRead(0)/10;                  
                  digitalWrite(relPin, LOW);//замок открыть дверь
                  digitalWrite(relPin2, LOW);//вход  показать зеленый на вход                
                  for (i1 = 0; i < 10; i1++){                  //искать значения из массива и сравнивать с переменной
                      if (mag == exi[i1]){                         
                        delay(2000);                    
                      break;                                             //совпало на верные значения круто                      
                      }}                        
                  for (i2 = 0; i2 < 10; i2++){                    
                      if (mag == bada[i2]){                                      //  ищем переменную в непрвельных значениях                         
                      digitalWrite(relPin3, LOW);//пищ                            //не правельное положение двери пищать сиреной
                      delay(2000);
                      digitalWrite(relPin3, HIGH);//пищ
                      break;                      
                      } }                                             
                      delay(2000);                                             //прошло 20 проходов вхиле
                      i = i +1;
                      }                        
                      digitalWrite(relPin, HIGH);//замок закрыть 
                      digitalWrite(relPin2, HIGH);//вход зажечь красный
delay(5000);
}

разделил счетчик, на i, i1, i2, убрал лишние брейки

раньше работало вот так:

 if (mag>6){
       ex = 5;
       bad = 2;  }
    else if (mag<3){
       ex = 7;
       bad = 5; }
    else{
       ex = 2;
       bad = 7; }
   i = 0;
   while (i < 20){
           mag = analogRead(0)/10;
       digitalWrite(relPin, LOW);//замок
       digitalWrite(relPin1, LOW);//вход       
       if (ex == mag){                      
                   // вышел
           break;
           }
          if (bad == mag){
                           // не правельно вышел
           digitalWrite(relPin3, LOW);//пищ
           delay(200);
           digitalWrite(relPin3, HIGH);//пищ
           break;
           }
           }             
           delay(250);
           i = i +1;}
          digitalWrite(relPin, HIGH);
          digitalWrite(relPin1, HIGH);
          digitalWrite(relPin2, HIGH);
          digitalWrite(relPin3, HIGH);          
          }

а сейчас хочу переделать на сравнение переменной mag с диапазонами значений

Простите, мне надоело клещами тянуть из Вас что же Вы хотите сделать. Не хотите или не можете объяснить толком - дело Ваше.

Ну дак учусь и поэтому не совсем понимаю как это работает:

Ардуинка смотрит за дверью и пищит если дверь открыта не правильно, датчик холла считывает угол в одну или в другую сторону,

в момент открытия ардуинка смотри показания в каком положении открыта дверь, это переменная mag, после нахождения положения, есть два варианта открытия двери, правильно ex и не правильно bad, отрываются реле - электромагнит и указатель, запускается цикл while, который отсчитывает время на открытие двери, после окончания открытия двери, датчик смотрит на конечное положение mag и сравнивает с тем которое получил ранее ex и bad, если mag = ex то выход правельный, если mag = bad, то выход неправельный и звучит реле сирена пищ.

когда были значения конкретные то кое как работало, а когда настали холода то показания разняться у датчика, и надо сделать для сравнения с mag диапазоны +- от этих конкретных значений.

Вот так сделал, все работает, всем спасибо!!!

  mag = analogRead(0)/10;
    if (mag > 10 && mag < 30){
       exi[0]= 86;exi[1]= 87;exi[2]= 86;exi[3]= 87;exi[4]= 86;exi[5]= 87;exi[6]= 86;exi[7]= 87;exi[8]= 86;exi[9]= 87;exi[10]= 86;exi[11]= 87;exi[12]= 86;exi[13]= 87;exi[14]= 86;exi[15]= 87;exi[16]= 86;exi[17]= 87;exi[18]= 86;exi[19]= 87;exi[20]= 86;exi[21]= 87;exi[22]= 86;exi[23]= 87;exi[24]= 86;exi[25]= 87;exi[26]= 86;exi[27]= 87;exi[28]= 86;exi[29]= 87;
       bada[0] = 51;bada[1] = 52;bada[2] = 53;bada[3] = 51;bada[4] = 52;bada[5] = 53;bada[6] = 51;bada[7] = 52;bada[8] = 53;bada[9] = 51; bada[10] = 52;bada[11] = 53;bada[12] = 51;bada[13] = 52;bada[14] = 53;bada[15] = 51;bada[16] = 52;bada[17] = 53;bada[18] = 51;bada[19] = 52;bada[20] = 53;bada[21] = 51;bada[22] = 52;bada[23] = 53;bada[24] = 51;bada[25] = 52;bada[26] = 53;bada[27] = 51;bada[28] = 52;bada[29] = 53;
       }
    else if (mag > 40 && mag < 60){
       exi[0]= 19;exi[1]= 18;exi[2]= 19;exi[3]= 18;exi[4]= 19;exi[5]= 18;exi[6]= 19;exi[7]= 18;exi[8]=19;exi[9]= 18;exi[10]= 19;exi[11]= 18;exi[12]= 19;exi[13]= 18;exi[14]= 19;exi[15]= 18;exi[16]= 19;exi[17]= 18;exi[18]=19;exi[19]= 18;exi[20]= 19;exi[21]= 18;exi[22]= 19;exi[23]= 18;exi[24]= 19;exi[25]= 18;exi[26]= 19;exi[27]= 18;exi[28]=19;exi[29]= 18;
       bada[0]= 87;bada[1]= 86;bada[2]= 86;bada[3]= 86;bada[4]= 87;bada[5]= 86;bada[6]= 86;bada[7]= 86;bada[8]= 87;bada[9]= 86;bada[10]= 87;bada[11]= 86;bada[12]= 86;bada[13]= 86;bada[14]= 87;bada[15]= 86;bada[16]= 87;bada[17]= 86;bada[18]= 87;bada[19]= 86;bada[20]= 87;bada[21]= 86;bada[22]= 86;bada[23]= 86;bada[24]= 87;bada[25]= 86;bada[26]= 87;bada[27]= 86;bada[28]= 87;bada[29]= 86;
       }
    else{
       exi[0] = 51;exi[1] = 52;exi[2] = 53;exi[3] = 51;exi[4] = 52;exi[5] = 53;exi[6] = 51;exi[6] = 52;exi[7] = 53;exi[8] = 51;exi[9] = 52;exi[10] = 53;exi[11] = 51;exi[12] = 52;exi[13] = 53;exi[14] = 51;exi[15] = 52;exi[16] = 53;exi[17] = 51;exi[18] = 52;exi[19] = 53;exi[20] = 51;exi[20] = 52;exi[21] = 53;exi[22] = 51;exi[23] = 52;exi[24] = 53;exi[25] = 51;exi[26] = 52;exi[27] = 53;exi[28] = 51;exi[29] = 52;
       bada[0]= 19;bada[1]= 18;bada[2]= 19;bada[3]= 18;bada[4]= 19;bada[5]= 18;bada[6]= 19;bada[7]= 18;bada[8]= 19;bada[9]= 18;bada[10]= 19;bada[11]= 18;bada[12]= 19;bada[13]= 18;bada[14]= 19;bada[15]= 18;bada[16]= 19;bada[17]= 18;bada[18]= 19;bada[19]= 18;bada[20]= 19;bada[21]= 18;bada[22]= 19;bada[23]= 18;bada[24]= 19;bada[25]= 18;bada[26]= 19;bada[27]= 18;bada[28]= 19;bada[29]= 18;
      }
   int i = 0;
   mag = analogRead(0)/10;
   digitalWrite(relPin, LOW);//замок
       digitalWrite(relPin1, LOW);//вход 
       delay(1500);
   while (i < 29){  
    Serial.print(mag);    
    Serial.print(exi[i]);
    Serial.println(bada[i]);     
         
             
     
       if (mag == exi[i]){           
           Serial.print("прошел"); 
           delay(50);                             
           break;
           }             
      else if (mag == bada[i] ){ 
           Serial.print("сломал"); 
           delay(50);           
           digitalWrite(relPin3, LOW);//пищ
           delay(200);
           digitalWrite(relPin3, HIGH);//пищ
           break;
           }                           
           delay(100);
           mag = analogRead(0)/10; 
           i = i +1;}
          digitalWrite(relPin, HIGH);
          digitalWrite(relPin1, HIGH);
          digitalWrite(relPin2, HIGH);
          digitalWrite(relPin3, HIGH); 
}

Какой кошмар

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

а можно пояснить, что это за массивы exi[] и bada[] ?

И нафига в них по 29 практически одинаковых значений, если, судя по коду -вы всего лишь ловите ЛЮБОЕ из 29 совпадений? - может заменить этот тупой перебор while на одно условие типа 

mag == 18 || mag == 19

А как это можно записать?

Так вы сначала поясните, зачем вы 29 раз сравниваете mag с одним и тем же хначением? (ибо 18 и 19 это практически одно и тоже в вашем коде, как я вижу)

29 раз потому, что while 29 раз проходит, значения одинаковые, потому что я не могу сделать перебор, что б он по времени был примерно 3-5 секунд.

кошмар....

Что мешает 29 раз с интервалом в 100 мс просто в цикле сравнить mag с числом 18? зачем для этого заводить массив из 29 одинаковых значений, ну что за бредятина?

вот так вот не лучше будет?

  mag = analogRead(0)/10;
    if (mag > 10 && mag < 30){
       exi_min = 86; exi_max = 87;
       bada_min = 51; bada_max = 53;
      }
    else if (mag > 40 && mag < 60){
       exi_min = 18; exi_max = 19;
       bada_min = 86; bada_max = 87;
       }
    else{
       exi_min = 51; exi_max = 53;
       bada_min = 18; bada_max = 19;
      }
   int i = 0;
   mag = analogRead(0)/10;
   digitalWrite(relPin, LOW);//замок
   digitalWrite(relPin1, LOW);//вход 
   delay(1500);
   while (i < 29){  
    Serial.print(mag);    
    if ((mag <= exi_max) && (mag >= exi_min)){           
           Serial.print("прошел"); 
           delay(50);                             
           break;
           }             
      else if ((mag <= bada_max) && (mag >= bada_min)){
           Serial.print("сломал"); 
           delay(50);           
           digitalWrite(relPin3, LOW);//пищ
           delay(200);
           digitalWrite(relPin3, HIGH);//пищ
           break;
           }                           
           delay(100);
           mag = analogRead(0)/10; 
           i = i +1;
    }
    digitalWrite(relPin, HIGH);
    digitalWrite(relPin1, HIGH);
    digitalWrite(relPin2, HIGH);
    digitalWrite(relPin3, HIGH); 
}

  mag = analogRead(0)/10;
    if (mag > 10 && mag < 30){
       exi_min = 86; exi_max = 87;
       bada_min = 51; bada_max = 53;
      }
    else if (mag > 40 && mag < 60){
       exi_min = 18; exi_max = 19;
       bada_min = 86; bada_max = 87;
       }
    else{
       exi_min = 51; exi_max = 53;
       bada_min = 18; bada_max = 19;
      }
   int i = 0;
   mag = analogRead(0)/10;
   digitalWrite(relPin, LOW);//замок
   digitalWrite(relPin1, LOW);//вход 
   delay(1500);
   while (i < 29){  
    Serial.print(mag);    
    if ((mag <= exi_max) && (mag >= exi_min)){           
           Serial.print("прошел"); 
           delay(50);                             
           break;
           }             
      else if ((mag <= bada_max) && (mag >= bada_min)){
           Serial.print("сломал"); 
           delay(50);           
           digitalWrite(relPin3, LOW);//пищ
           delay(200);
           digitalWrite(relPin3, HIGH);//пищ
           break;
           }                           
           delay(100);
           mag = analogRead(0)/10; 
           i = i +1;
    }
    digitalWrite(relPin, HIGH);
    digitalWrite(relPin1, HIGH);
    digitalWrite(relPin2, HIGH);
    digitalWrite(relPin3, HIGH); 
}

СПАСИБО, век живи век учись :))))

Сдается мне , что сам подход в корне неправильный.

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

Поправил код исключительно из эстетических соображений