Устранение дребезга в матричной клавиатуре

Tamer
Tamer аватар
Offline
Зарегистрирован: 24.06.2012

Подключил клавиатуру 4 х 3 с помощью библиотеки Keypad.h

Скетч

/* @file CustomKeypad.pde
|| @version 1.0
|| @author Alexander Brevig
|| @contact alexanderbrevig@gmail.com
||
|| @description
|| | Demonstrates changing the keypad size and key values.
|| #
*/
#include <Keypad.h>

const byte ROWS = 4; //four rows
const byte COLS = 3; //four columns
//define the cymbols on the buttons of the keypads
char hexaKeys[ROWS][COLS] = {
  {'7','8','9'},
  {'4','5','6'},
  {'1','2','3'},
  {'*','0','#'}
};
byte rowPins[ROWS] = {3, 2, 8, 0}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {7, 6, 5}; //connect to the column pinouts of the keypad

//initialize an instance of class NewKeypad
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); 

void setup(){
  Serial.begin(9600);
}
  
void loop(){
  char customKey = customKeypad.getKey();
  
  if (customKey != NO_KEY){
    Serial.println(customKey);
  }
}

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

maksim
Offline
Зарегистрирован: 12.02.2012

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

/* @file CustomKeypad.pde
|| @version 1.0
|| @author Alexander Brevig
|| @contact <a href="mailto:alexanderbrevig@gmail.com">alexanderbrevig@gmail.com</a>
||
|| @description
|| | Demonstrates changing the keypad size and key values.
|| #
*/
#include <Keypad.h>

const byte ROWS = 4; //four rows
const byte COLS = 3; //four columns
//define the cymbols on the buttons of the keypads
char hexaKeys[ROWS][COLS] = {
  {'7','8','9'},
  {'4','5','6'},
  {'1','2','3'},
  {'*','0','#'}
};
byte rowPins[ROWS] = {3, 2, 8, 0}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {7, 6, 5}; //connect to the column pinouts of the keypad

//initialize an instance of class NewKeypad
Keypad customKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS); 

void setup(){
  Serial.begin(9600);
}
  
void loop(){
  char customKey = customKeypad.getKey();
  
  if (customKey != NO_KEY){
    delay(150);
    Serial.println(customKey);
  }
}

 

AlexFisher
AlexFisher аватар
Offline
Зарегистрирован: 20.12.2011

Лучше наверно будет:

void loop(){
  char customKey = customKeypad.getKey();
  
  if (customKey != NO_KEY){
    delay(150);
    if (customKey == customKeypad.getKey()) //проверяем, что до сих пор нажата эта же кнопка
    {    
      Serial.println(customKey);
      while (customKeypad.getKey() != NO_KEY); //ждем отпускания
    }  
  }
}

 

Tazzzz
Offline
Зарегистрирован: 09.04.2014

Здравствуйте. Помогите пожалуйста новечку. Как мне вписать в мой скетч защиту от дребезга приведённую выше. Строка 442.


[code]
// монетоприемник на одну монету (жетон) - HI-N07CS
const int moneyPin2=3;

int pulse2=0;
unsigned long timeAllPulse2=1500; // макс. время приема монеты
unsigned long timeCount2=0;
unsigned int sum=0;

// EEPROM для хранения настроек
//0-1 - номинал
//      интервалы
//2-      
#include <EEPROM.h>

#include <OneWire.h>
OneWire  ds(19);  // on pin A5
unsigned long millistemp=0;
int t_temp=0;
int heating=0;
#define TEMP1 0
#define TEMP2 0
int z1,z2;
byte my_addr[8]={0x28,0x37,0xEF,0x25,6,0,0,0xE3};
//28 D9 F6 26 6 0 0 DE
//#include <SPI.h>
//#define spiRelay 8 
//#define spiDisplay 10
//#define keyPin1 14
//#define keyPin2 15

#define MPAUSE1 5000 

unsigned long time_millis1=0;
int pause1=0;
int valbutton=0;
unsigned long millisbutton1[9]={0,0,0,0,0,0,0,0,0};
//Установки, зачений програм.
unsigned long tekinterval1[9]={2000,10,10,10,10,10,6,1800,1};
unsigned long mininterval1[9]={10,1,1,1,1,1,1,10,1};
unsigned long maxinterval1[9]={10000,100,100,100,100,100,100,10000,1};
unsigned long stepinterval1[9]={10,1,1,1,1,1,1,10,1};

int tekprg=0;
int tekprgpr=0;
unsigned long millisinterval=0;
unsigned long millispause1=0;
// дисплей WH1602
//#include <LiquidCrystal.h>
//LiquidCrystal lcd(10,9,7,6,5,4);


#include <MaxMatrix.h>
MaxMatrix m(7,6,5,5);
byte comma[] = {
  1,  8, B11000000};

byte figure[41][10]={
   {8,8,                 //0
    B00000000,
    B01111110,
    B11111111,
    B11000011,
    B11000011,
    B11000011,
    B11111111,
    B01111110},
   {8,8,                 //1
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000100,
    B00000110,
    B11111111,
    B11111111},
   {8,8,               //2
    B00000000,   
    B11000110,
    B11100111,
    B11110011,
    B11111011,
    B11011111,
    B11001111,
    B11000110},
   {8,8,                 //3
    B00000000,
    B01100110,
    B11100111,
    B11000011,
    B11011011,
    B11011011,
    B11111111,
    B01100110},
   {8,8,                 //4
    B00000000,
    B00011111,
    B00011111,
    B00011000,
    B00011000,
    B00011000,
    B11111111,
    B11111111},
   {8,8,                 //5
    B00000000,
    B01011111,
    B11011111,
    B11011011,
    B11011011,
    B11011011,
    B11111011,
    B01110011},
   {8,8,                 //6
    B00000000,
    B01111110,
    B11111111,
    B11011011,
    B11011011,
    B11011011,
    B11111011,
    B01110010},
   {8,8,                 //7
    B00000000,
    B00000011,
    B00000011,
    B11110011,
    B11111011,
    B00001111,
    B00000111,
    B00000011},
   {8,8,                 //8
    B00000000,
    B01100110,
    B11111111,
    B11011011,
    B11011011,
    B11011011,
    B11111111,
    B01100110},
   {8,8,                 //9
    B00000000,
    B01001110,
    B11011111,
    B11011011,
    B11011011,
    B11011011,
    B11111111,
    B01111110},
   {8,8,                 //пустота
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000},
   {8,8,                 //для мигания
    B01100111,
    B11100011,
    B01110001,
    B01101000,
    B01101000,
    B01101001,
    B11110011,
    B01100111},
   {8,8,                 //прогр. номинал
    B00011111,
    B00000100,
    B00011111,
    B00000000,
    B00100000,
    B00010000,
    B11111000,
    B00000000},
   {8,8,                 //прогр. задержка 1
    B00000001,
    B00011111,
    B00000001,
    B00000000,
    B00100000,
    B00010000,
    B11111000,
    B00000000},
   {8,8,                 //прогр. задержка 2
    B00000001,
    B00011111,
    B00000001,
    B00000000,
    B10001000,
    B11001000,
    B10111000,
    B00000000},
   {8,8,                 //прогр. задержка 3
    B00000001,
    B00011111,
    B00000001,
    B00000000,
    B10101000,
    B10101000,
    B11111000,
    B00000000},
   {8,8,                 //прогр. задержка 4
    B00000001,
    B00011111,
    B00000001,
    B00000000,
    B00111000,
    B00100000,
    B11111000,
    B00000000},
   {8,8,                 //прогр. задержка 5
    B00000001,
    B00011111,
    B00000001,
    B00000000,
    B10111000,
    B10101000,
    B11101000,
    B00000000},
   {8,8,                 //прогр. задержка 6
    B00000001,
    B00011111,
    B00000001,
    B00000000,
    B11100000,
    B10110000,
    B11101000,
    B00000000},
   {8,8,                 //прогр. пауза
    B00011111,
    B00000101,
    B00000111,
    B00000000,
    B00100000,
    B00010000,
    B11111000,
    B00000000},
   {8,8,                 //скорость бегущей строки и выполнение программы 0
    B01100111,
    B11100011,
    B01110001,
    B01101000,
    B01101000,
    B01101001,
    B11110011,
    B01100111},
  {8,8,                 //выполнение программы 1
    B00000000,
    B00000000,
    B00001000,
    B00000100,
    B11111110,
    B00000000,
    B00000000,
    B11111111},
   {8,8,                 //выполнение программы 2
    B11000100,
    B10100010,
    B10010010,
    B10010010,
    B10010010,
    B10001100,
    B00000000,
    B11111111},
   {8,8,                 //выполнение программы 3
    B01000100,
    B10000010,
    B10000010,
    B10010010,
    B10010010,
    B01101100,
    B00000000,
    B11111111},
   {8,8,                 //выполнение программы 4
    B00011110,
    B00010000,
    B00010000,
    B00010000,
    B00010000,
    B11111110,
    B00000000,
    B11111111},
   {8,8,                 //выполнение программы 5
    B01001110,
    B10001010,
    B10001010,
    B10001010,
    B10001010,
    B01110010,
    B00000000,
    B11111111},
   {8,8,                 //выполнение программы 6
    B01111100,
    B10010010,
    B10010010,
    B10010010,
    B10010010,
    B01100100,
    B00000000,
    B11111111},
   {8,8,                 //выполнение программы пауза
    B01001100,
    B10010010,
    B10010010,
    B10010010,
    B10010010,
    B01100100,
    B00000000,
    B11111111},
   {8,8,                 //№
    B11111000,
    B00010000,
    B00100000,
    B01000000,
    B11111000,
    B00000111,
    B00000101,
    B00000111},
   {8,8,                 //буква П
    B00000000,
    B11111111,
    B11111111,
    B00000011,
    B00000011,
    B00000011,
    B11111111,
    B11111111},
   {8,8,                 //буква У
    B00000000,
    B01001111,
    B11011111,
    B11011000,
    B11011000,
    B11011000,
    B11111111,
    B01111111},
   {8,8,                 //буква С
    B00000000,
    B01111110,
    B11111111,
    B11000011,
    B11000011,
    B11000011,
    B11000011,
    B01000010},
   {8,8,                 //буква Т
    B00000000,
    B00000000,
    B00000011,
    B00000011,
    B11111111,
    B11111111,
    B00000011,
    B00000011},
   {8,8,                 //буква И
    B00000000,
    B11111111,
    B11111111,
    B00110000,
    B00011000,
    B00001100,
    B11111111,
    B11111111},
   {8,8,                 //буква Е
    B00000000,
    B11111111,
    B11111111,
    B11011011,
    B11011011,
    B11011011,
    B11000011,
    B11000011},
   {8,8,                 //буква Ж
    B00000000,
    B11111111,
    B11111111,
    B11011011,
    B11011011,
    B11011011,
    B11111111,
    B01100110},
   {8,8,                 //буква Н
    B00000000,
    B11111111,
    B11111111,
    B00011000,
    B00011000,
    B00011000,
    B11111111,
    B11111111},
   {8,8,                 //знак=
    B00000000,
    B11000000,
    B11111111,
    B11111111,
    B00000011,
    B00000011,
    B11111111,
    B11111111},
   {8,8,                 //Л 
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000111,
    B00000101,
    B00000111,
    B00000000},
   {8,8,                 //знак - 
    B00000000,
    B00000000,
    B00001000,
    B00001000,
    B00001000,
    B00001000,
    B00000000,
    B00000000},
   {8,8,                 //знак -    
    B00000000,
    B11111110,
    B11111111,
    B00110011,
    B00110011,
    B00110011,
    B11111111,
    B11111110},
  };





int per1=0;
  




#include <Keypad.h>

const byte ROWS = 4; //four rows
const byte COLS = 4; //four columns
char keys[ROWS][COLS] = {
    {'1','2','3','a'},
    {'4','5','6','b'},
    {'7','8','9','c'},
    {'*','0','#','d'}
};

byte rowPins[ROWS] = {14, 15, 16, 17}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {18, 19, 9, 4}; //connect to the column pinouts of the keypad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
char key=' ';


// *********************************
int prg=0;
int pos_options=0;
//char* str_options[7]={"nominal","delay1 ","delay2 ","delay3 ","delay4 ","delay5 ","delay6 "};
int kstep=1;

unsigned long millisblink=0;
int blink1=0;int blink0=0;
byte arrblink[]={35,36,34,31,33,32,34,10,0,29,37,40,32,30,10,29,0,31,32,28,4,10,38,31,10,10,10,};
//** выводы реле
int arrrelay[7]={2,8,10,11,12,3,13};
//byte arrdorelay[8][6]={{1,1,1,0,1,0},{0,1,1,0,1,0},{0,0,1,0,1,0},
//                       {0,0,1,1,1,0},{0,0,0,0,1,0},{0,0,0,0,0,1},
//                       {0,0,0,0,0,0},{0,0,0,0,0,0}};
//byte arrdorelay[8][7]={{0,0,0,1,0,0,0},{1,0,0,1,0,1,1},{1,1,0,1,0,1,1},
//                       {1,1,0,0,1,1,1},{1,1,1,1,0,1,1},{1,1,0,1,0,0,1},
//                       {1,1,1,1,1,1,1},{1,1,1,1,1,1,1}};
byte arrdorelay[8][7]={{1,1,1,0,1,0,1},{0,1,1,0,1,0,0},{0,0,1,0,1,0,0},
                       {0,0,1,1,1,0,0},{0,0,0,0,1,0,0},{0,0,1,0,0,1,0},
                       {0,0,0,0,0,0,0},{0,0,0,0,0,0,0}}; 
unsigned long millisblinkrelay4=0;
boolean blinkrelay4=true;

#include <MsTimer2.h>
void flash()
  {
  if(sum>0)
    return;
  MsTimer2::stop();
  blink0=(blink0+1)%8;
  if(blink0==0)    
    blink1=(blink1+1)%sizeof(arrblink);
  for(int i=0;i<6;i++)
      {
      m.writeSprite(i*8-blink0,0,figure[arrblink[(blink1+i)%sizeof(arrblink)]]);
      } 
  MsTimer2::set(tekinterval1[8]*10, flash); //  period
  MsTimer2::start();
  }

unsigned long millisendprg=0;
unsigned long millis3=0;

void setup()
{
  Serial.begin(9600);
  pinMode(moneyPin2,INPUT);
  //attachInterrupt(0,count_pulse,FALLING);
  //attachInterrupt(1,count_pulse2,FALLING);

 m.init();
  m.setIntensity(15);
   Serial.println("setup ok!!");
  if(EEPROM.read(511)!=55)
  for(int i=0;i<9;i++)
     {EEPROM.write(i*2,highByte(tekinterval1[i]));
     EEPROM.write(i*2+1,lowByte(tekinterval1[i]));}     
  EEPROM.write(511,55);
  for(int i=0;i<9;i++)
      {
      tekinterval1[i]=(EEPROM.read(i*2)<<8)+EEPROM.read(i*2+1);
      Serial.println(tekinterval1[i]);
      }
  
  //** выводы реле 2,8,10,11,12,13
  for(int i=0;i<7;i++)
    {pinMode(arrrelay[i],OUTPUT);delay(20);digitalWrite(arrrelay[i],LOW);}
    
  
  Serial.println("spiok!!");
  m.writeSprite(0, 0, figure[11]);
  m.writeSprite(8, 0, figure[0]);
  m.writeSprite(16,0, figure[0]);
  m.writeSprite(24, 0, figure[0]);
  m.writeSprite(32, 0, figure[0]);
  delay(2000);
  //attachInterrupt(1,count_pulse2,FALLING);
    t_temp=get_temp();
    if(t_temp<999)
    {
    //t_temp=t_temp;
    z1=abs(t_temp)/10;
    z2=byte(abs(t_temp)%10);
    //arrblink[22]=byte(z2);
    if(t_temp<0)
      arrblink[21]=39;
    else
      arrblink[21]=10; 
    if(z1<1)
      {arrblink[22]=byte(z2);arrblink[23]=38;arrblink[24]=31;arrblink[25]=10;}
    else
      {arrblink[22]=byte(z1);arrblink[23]=byte(z2);arrblink[24]=38;arrblink[25]=31;}
    }
}

void loop()
{
if(prg==1)
  {
  
  key = keypad.getKey();
  if(key)
    {doForKey(key);heating=0;}
  }
else
  {
  //
  if(millis()-millisblink>tekinterval1[8]*10 && sum==0)
    {
    millisblink=millis();
    blink0=(blink0+1)%8;
    if(blink0==0)    
      blink1=(blink1+1)%sizeof(arrblink);
    for(int i=0;i<6;i++)
        {
        m.writeSprite(i*8-blink0,0,figure[arrblink[(blink1+i)%sizeof(arrblink)]]);
        }
      }
  //
  if(millis()-millistemp>6000 && sum==0)
    {
    MsTimer2::set(tekinterval1[8]*10, flash); //  period
    MsTimer2::start();     
    t_temp=get_temp();
    if(t_temp<999)
    {
    //t_temp=t_temp;
    z1=abs(t_temp)/10;
    z2=byte(abs(t_temp)%10);
    //arrblink[22]=byte(z2);
    if(t_temp<0)
      arrblink[21]=39;
    else
      arrblink[21]=10; 
    if(z1<1)
      {arrblink[22]=byte(z2);arrblink[23]=38;arrblink[24]=31;arrblink[25]=10;}
    else
      {arrblink[22]=byte(z1);arrblink[23]=byte(z2);arrblink[24]=38;arrblink[25]=31;}
    String t1=" t="+String(t_temp);
    Serial.print("temp=");Serial.println(int(t_temp));
    //Serial.println(z1);Serial.print(' ');Serial.print(z2);Serial.println();
    //Serial.println(t1);
    for(int j=21;j<26;j++)
      {Serial.print(arrblink[j],DEC);Serial.print(' ');
      }
    //Serial.println();
    millistemp=millis();
    }  
   else
     Serial.println("no temp"); 
   MsTimer2::stop();     
   }
  // прошло максимальное время приема монеты?
  if(pulse2>0 && (millis()-timeCount2)>timeAllPulse2) 
    {
    //Serial.println("moneta - ok");
    //Serial.println(EEPROM.read(0));
    //Serial.println(EEPROM.read(1));
    
    //sum=sum+(EEPROM.read(0)<<8)+EEPROM.read(1);
    sum=sum+tekinterval1[0];
    //Serial.print("sum=");Serial.println(sum);
    view_figure(sum,1);
    pulse2=0;  
    }

    
    key = keypad.getKey();
    if(key)
       {doForKey(key);heating=0;}
    
  if((millis()-millisinterval)>tekinterval1[tekprg]*100 && pause1==0 && tekprg>0 && tekprg<7 && sum>0)  
    {
    millisinterval=millis();
    sum=sum-10;
    //show_sum(sum);
    view_figure(sum,1);
    if(sum==0)
      {tekprg=0;send_led(8);send_relay(8);blink1=0;blink0=0;
       heating=0;millisendprg=millis();
       digitalWrite(arrrelay[0],1);
       }  
    }
  //
  if(pause1==1)
    {
    if((millis()-millispause1)>tekinterval1[7]*100)
      {pause1=0;
      tekprg=5;//tekprg=tekprgpr;
      send_led(tekprg);
      send_relay(tekprg);
      millispause1=millis()-10000;
      millisendprg=millis()-20000;
      heating=0;
      //Serial.print("pause1=");Serial.println(pause1);
      //Serial.print("tekprg=");Serial.println(tekprg);
      
      }
    }  
  //Serial.print("A0=");Serial.println(analogRead(A0));
 }
 if(t_temp<TEMP1 && (tekprg==2 || tekprg==3 || tekprg==4 || tekprg==6)
    && millis()-millis3<10000)
   {heating=1;//Serial.println("ON");
   digitalWrite(arrrelay[6],1);
   }
 if((tekprg==2 || tekprg==3 || tekprg==4 || tekprg==6) && millis()-millis3>10000)
   {heating=1;//Serial.println("OFF");
   digitalWrite(arrrelay[6],0);
   }
 if(millis()-millispause1>8000 && millis()-millisendprg>8000 && (tekprg==0 || tekprg==7 ))
   {
   digitalWrite(arrrelay[0],0);
   }
 // blink relay4
  if(tekprg==4)
     {
     if(blinkrelay4==true && (millis()-millisblinkrelay4)>100)
        {  // выкл
        blinkrelay4=false;
        millisblinkrelay4=millis();
        digitalWrite(arrrelay[3],LOW);  
        }
     else if(blinkrelay4==false && (millis()-millisblinkrelay4)>1000)
        {  // вкл
        blinkrelay4=true;
        millisblinkrelay4=millis();
        digitalWrite(arrrelay[3],HIGH);  
        }
       
     }
}

// обработка нажатия кнопки
void doForKey(char key) {
 //Serial.print("key="); Serial.println(key);
 switch(key)
   {
   case '1': if(prg<1 && sum>0)
                {tekprg=1;pause1=0;send_relay(1);view_figure(sum,1);}
      break; 
   case '2': if(prg<1 && sum>0)
                {tekprg=2;pause1=0;send_relay(2);view_figure(sum,1);millis3=millis();}
      break; 
   case '3': if(prg<1 && sum>0)
                {tekprg=3;pause1=0;send_relay(3);view_figure(sum,1);millis3=millis();}
      break; 
   case '4': if(prg<1 && sum>0)
                {tekprg=4;pause1=0;send_relay(4);view_figure(sum,1);millis3=millis();}
      break; 
   case '5': if(prg<1 && sum>0)
                {tekprg=5;pause1=0;send_relay(5);view_figure(sum,1);}
      break; 
   case '6': if(prg<1 && sum>0)
                {tekprg=6;pause1=0;send_relay(6);view_figure(sum,1);millis3=millis();}
      break; 
   case '7': if(prg<1 && sum>0 && tekprg>0)
                {tekprgpr=tekprg;pause1=1;millispause1=millis();
                send_relay(7);tekprg=7;view_figure(sum,1);millis3=millis();
                digitalWrite(arrrelay[0],1);
                }
      break; 
  // case '*': prg=1-prg;
             if(prg==1)
              {show_prg(pos_options);send_relay(8);
              send_led(8);tekprg=0;
              }
             else {
             //show_sum(sum);
             sum=0;
             //view_figure(sum,1);
             blink1=0;blink0=0;
             pos_options=0;tekprg=0;}
      break;
   case '9': if(prg==1)  // следующий параметр
               {
               pos_options=(pos_options+1)%9;
               Serial.print("pos_options="); Serial.println(pos_options);
               show_prg(pos_options);
               }
      break;
  case 'd': // +монета 
             sum=sum+tekinterval1[0];
             view_figure(sum,1);
             pulse2=0;  
       break;
  // case 'b':  sum=10;
              // обнуление (было предыдущий параметр)
               /*if(prg==1)  
               {
               pos_options=pos_options-1;
               if(pos_options<0)
                 pos_options=8;
               show_prg(pos_options);
               }*/
      break;
   case '0': if(prg==1)  // уменьшение значения
               {
               if(stepinterval1[pos_options]*kstep<tekinterval1[pos_options])  
                  tekinterval1[pos_options]=tekinterval1[pos_options]-stepinterval1[pos_options]*kstep;
               else
                  tekinterval1[pos_options]=0;
               tekinterval1[pos_options]=max(tekinterval1[pos_options],mininterval1[pos_options]);
               show_prg(pos_options);
               }
      break; 
   case '8': if(prg==1)  // увеличение значения
               {
               tekinterval1[pos_options]=tekinterval1[pos_options]+stepinterval1[pos_options]*kstep;
               tekinterval1[pos_options]=min(tekinterval1[pos_options],maxinterval1[pos_options]);
               show_prg(pos_options);
               }
      break; 
   case '#': if(prg==1)  // коэффициент*10
               {
               kstep=10/kstep;
               }
      break; 
   case 'a': if(prg==1)  // сохранить настройки
               {;
               for(int i=0;i<9;i++)
                 {EEPROM.write(i*2,highByte(tekinterval1[i]));
                  EEPROM.write(i*2+1,lowByte(tekinterval1[i]));}     
               }
      break; 
   case 'с': if(prg==1)  // не сохранять настройки
               {;
               for(int i=0;i<9;i++)
                 {
                 tekinterval1[i]=(EEPROM.read(i*2)<<8)+EEPROM.read(i*2+1);
                 Serial.println(tekinterval1[i]);
                 }
               }
      break; 
   default:
      break; 
   }
   
 }
// обработка прерывания монетоприемника - получить кол-во импульсов
//  
void count_pulse2()
  {
  //detachInterrupt(0);
  detachInterrupt(1);
  pulse2++;
  if(pulse2==1)
    timeCount2=millis();
  //attachInterrupt(0,count_pulse,FALLING);
  attachInterrupt(1,count_pulse2,FALLING);
  }
// индикация отсчета
void show_sum(int val)
  {
    float sum1;
    //lcd.setCursor(2,0);lcd.print("working    ");
    //lcd.setCursor(2,1);lcd.print("           ");
    sum1=float(val)/10;
    //lcd.setCursor(2,1);
    //lcd.print(sum1);
  }
// индикация настройки
void show_prg(int val)
  {
    float interval1;
    
    //lcd.setCursor(2,0);
    //lcd.print(str_options[val]);
    //lcd.setCursor(2,1);
    //lcd.print("            ");
    //interval1=float(tekinterval1[val])/10;
    //lcd.setCursor(2,1);
    //lcd.print(interval1);
    view_figure(tekinterval1[val],2);
  }

// запуск/останов реле
void send_relay(int val)
  {
  //Serial.print("sendrelay=");Serial.println(val);

  for(int i=0;i<7;i++)
    digitalWrite(arrrelay[i],LOW);
  if(val<5)
    {digitalWrite(arrrelay[4],HIGH);
     delay(1000);}
  else if(val==6)
    {digitalWrite(arrrelay[5],HIGH);
     delay(1000);}
  else ;
  for(int i=0;i<7;i++)
    digitalWrite(arrrelay[i],arrdorelay[val-1][i]);
   
  }
// запуск/останов реле+светодиодов
void send_led(byte val)
  {
  //digitalWrite(spiRelay,LOW);
  //SPI.transfer(B00000001<<(tekprg-1));
  //SPI.transfer(B00000001<<(val-1));
  //SPI.transfer(B00000001<<(val-1));
  //digitalWrite(spiRelay,HIGH); 
  }
// показать цифры
void view_figure(unsigned int num,int mode)
  {
  int num1,num2,num3,num4,num5;
  num1=num/10000;
  num2=(num-num1*10000)/1000;
  num3=(num-num1*10000-num2*1000)/100;
  num4=(num-num1*10000-num2*1000-num3*100)/10;
  num5=num-num1*10000-num2*1000-num3*100-num4*10;
  //Serial.print("num1="); Serial.print(num1);
  //Serial.print(" num2="); Serial.print(num2);
  //Serial.print(" num3="); Serial.print(num3);
  //Serial.print(" num4="); Serial.print(num4);
  if(num5>0)
    {
    m.writeSprite(32, 0, figure[num5]);
    m.writeSprite(24, 0, figure[num4]);
    m.writeSprite(16,0, figure[num3]);
    m.writeSprite(8, 0, figure[num2]);
    m.writeSprite(32,0, comma);
    }
  else
    {
    m.writeSprite(32, 0, figure[num4]);
    m.writeSprite(24, 0, figure[num3]);
    m.writeSprite(16,0, figure[num2]);
    m.writeSprite(8, 0, figure[num1]);
    }
  if(mode>1)
    {
    m.writeSprite(0, 0, figure[pos_options+12]);
    }  
  else
    m.writeSprite(0, 0, figure[tekprg+20]);
  }
 // получение тмпературы датчика
int get_temp()
 {
byte i;
byte present = 0;
byte data[12];
byte addr[8];
int Temp,SignBit;
  /*if ( !ds.search(addr)) {
        //Serial.print("No more addresses.\n");
        ds.reset_search();
        return 999;
  }
  Serial.print("R=");  //R=28 Not sure what this is
  for( i = 0; i < 8; i++) {
    Serial.print(addr[i], HEX);
    Serial.print(" ");
  }
  if ( OneWire::crc8( addr, 7) != addr[7]) {
        Serial.print("CRC is not valid!\n");
        return 0;
  }
  if ( addr[0] != 0x28) {
        Serial.print("Device is not a DS18S20 family device.\n");
        return 0;
  }*/
  ds.reset();
  ds.select(my_addr);
  ds.write(0x44,1);        // start conversion, with parasite power on at the end
  //delay(100);     // maybe 750ms is enough, maybe not
  // we might do a ds.depower() here, but the reset will take care of it.

  present = ds.reset();
  ds.select(my_addr);
  ds.write(0xBE);          // Read Scratchpad
  for ( i = 0; i < 9; i++) {         // we need 9 bytes
    data[i] = ds.read();
  }
  Temp=(data[1]<<8)+data[0];//take the two bytes from the response relating to temperature
   // Проверяем - или нет
     Temp = Temp/16.4;  
  return Temp;
 }

[/code]