Пьезо кнопки самостаятельное переключение.

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

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

Кнопки установлены пьезо, типа сенроных, два контакта. Проблема во время работы самостоятельное переключение кнопок, чаще с 1 на 2. Как это можно решить. Спасибо.

Tazzzz
Offline
Зарегистрирован: 09.04.2014
// монетоприемник на одну монету (жетон) - HI-N07CS
const int moneyPin2=3;

int pulse2=0;
unsigned long timeAllPulse2=500; // макс. время приема монеты
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 20
#define TEMP2 20
int z1,z2;
byte my_addr[8]={0x28,0xD9,0xF6,0x26,6,0,0,0xDE};
//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]={1500,80,60,3,9,10,70,50,9};
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,20};
unsigned long stepinterval1[9]={10,1,1,1,1,1,1,10,10};

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[40][10]={
   {8,8,                 //0
    B00000000,
    B11111111,
    B11111111,
    B11000011,
    B11000011,
    B11000011,
    B11111111,
    B11111111},
   {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,
    B11000011,
    B11011011,
    B11011011,
    B11011011,
    B11011011,
    B11111111,
    B11111111},
   {8,8,                 //4
    B00000000,
    B00011111,
    B00011111,
    B00011000,
    B00011000,
    B00011000,
    B11111111,
    B11111111},
   {8,8,                 //5
    B00000000,
    B11011111,
    B11011111,
    B11011011,
    B11011011,
    B11011011,
    B11111011,
    B11111011},
   {8,8,                 //6
    B00000000,
    B11111111,
    B11111111,
    B11011011,
    B11011011,
    B11011011,
    B11111011,
    B11111011},
   {8,8,                 //7
    B00000000,
    B00000011,
    B00000011,
    B11110011,
    B11111011,
    B00001111,
    B00000111,
    B00000011},
   {8,8,                 //8
    B00000000,
    B11111111,
    B11111111,
    B11011011,
    B11011011,
    B11011011,
    B11111111,
    B11111111},
   {8,8,                 //9
    B00000000,
    B11011111,
    B11011111,
    B11011011,
    B11011011,
    B11011011,
    B11111111,
    B11111111},
   {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
    B00011111,
    B00000001,
    B00011111,
    B00000000,
    B00100000,
    B00010000,
    B11111000,
    B00000000},
   {8,8,                 //выполнение программы 2
    B00011111,
    B00000001,
    B00011111,
    B00000000,
    B10001000,
    B11001000,
    B10111000,
    B00000000},
   {8,8,                 //выполнение программы 3
    B00011111,
    B00000001,
    B00011111,
    B00000000,
    B10101000,
    B10101000,
    B11111000,
    B00000000},
   {8,8,                 //выполнение программы 4
    B00011111,
    B00000001,
    B00011111,
    B00000000,
    B00111000,
    B00100000,
    B11111000,
    B00000000},
   {8,8,                 //выполнение программы 5
    B00011111,
    B00000001,
    B00011111,
    B00000000,
    B10111000,
    B10101000,
    B11101000,
    B00000000},
   {8,8,                 //выполнение программы 6
    B00011111,
    B00000001,
    B00011111,
    B00000000,
    B11100000,
    B10110000,
    B11101000,
    B00000000},
   {8,8,                 //выполнение программы пауза
    B00011111,
    B00000001,
    B00011111,
    B00000000,
    B11111000,
    B00001000,
    B11111000,
    B00000000},
   {8,8,                 //пустота
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000},
   {8,8,                 //буква П
    B00000000,
    B11111111,
    B11111111,
    B00000011,
    B00000011,
    B00000011,
    B11111111,
    B11111111},
   {8,8,                 //буква У
    B00000000,
    B00000000,
    B00000001,
    B10000011,
    B11000110,
    B01101100,
    B00111111,
    B00011111},
   {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,
    B11000011,
    B01100110,
    B00111100,
    B11111111,
    B00111100,
    B01100110,
    B11000011},
   {8,8,                 //буква Н
    B00000000,
    B11111111,
    B11111111,
    B00011000,
    B00011000,
    B00011000,
    B11111111,
    B11111111},
   {8,8,                 //знак=
    B00000000,
    B00000000,
    B00010100,
    B00010100,
    B00010100,
    B00010100,
    B00010100,
    B00000000},
   {8,8,                 //знак градус 
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000111,
    B00000101,
    B00000111,
    B00000000},
   {8,8,                 //знак - 
    B00000000,
    B00000000,
    B00001000,
    B00001000,
    B00001000,
    B00001000,
    B00000000,
    B00000000},
  };





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[]={10,10,10,0,29,30,31,32,33,32,34,10,35,34,32,0,36,10,32,37,10,10,10,38,31};
//** выводы реле
int arrrelay[6]={2,8,10,11,12,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][6]={{0,0,0,1,0,1},{1,0,0,1,0,1},{1,1,0,1,0,1},
                       {1,1,0,0,0,1},{1,1,1,1,0,1},{1,1,1,1,1,0},
                       {1,1,1,1,1,1},{1,1,1,1,1,1}};
                       
#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;

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!!");
  //*****************************************
  //for(int i=0;i<8;i++)
  //   {EEPROM.write(i*2,highByte(tekinterval1[i]));
  //   EEPROM.write(i*2+1,lowByte(tekinterval1[i]));}     
  //*****************************************
  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<6;i++)
    {pinMode(arrrelay[i],OUTPUT);delay(20);digitalWrite(arrrelay[i],HIGH);}
    
  
  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[20]=39;
    else
      arrblink[20]=10; 
    if(z1<1)
      {arrblink[21]=byte(z2);arrblink[22]=38;arrblink[23]=31;arrblink[24]=10;}
    else
      {arrblink[21]=byte(z1);arrblink[22]=byte(z2);arrblink[23]=38;arrblink[24]=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>60000 && 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[20]=39;
    else
      arrblink[20]=10; 
    if(z1<1)
      {arrblink[21]=byte(z2);arrblink[22]=38;arrblink[23]=31;arrblink[24]=10;}
    else
      {arrblink[21]=byte(z1);arrblink[22]=byte(z2);arrblink[23]=38;arrblink[24]=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=20;j<25;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();
       }  
    }
  //
  if(pause1==1)
    {
    if((millis()-millispause1)>tekinterval1[7]*100)
      {pause1=0;
      tekprg=5;//tekprg=tekprgpr;
      send_led(tekprg);
      send_relay(tekprg);
      //Serial.print("pause1=");Serial.println(pause1);
      //Serial.print("tekprg=");Serial.println(tekprg);
      
      }
    }  
  //Serial.print("A0=");Serial.println(analogRead(A0));
 } 

 if(t_temp<TEMP1 && heating==0 && millis()-millispause1>10000 && millis()-millisendprg>20000)
   {heating=1;//Serial.println("ON");
   digitalWrite(arrrelay[0],0);digitalWrite(arrrelay[4],0);
   }
 if(t_temp>TEMP2 && heating==1)
   {heating=0;//Serial.println("OFF");
   digitalWrite(arrrelay[0],1);digitalWrite(arrrelay[4],1);
   }
 
}

// обработка нажатия кнопки
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);}
      break; 
   case '3': if(prg<1 && sum>0)
                {tekprg=3;pause1=0;send_relay(3);view_figure(sum,1);}
      break; 
   case '4': if(prg<1 && sum>0)
                {tekprg=4;pause1=0;send_relay(4);view_figure(sum,1);}
      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);}
      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);
                }
      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 'a': // +монета 
             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 'd': 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<6;i++)
    digitalWrite(arrrelay[i],HIGH);
  if(val<5)
    {digitalWrite(arrrelay[4],LOW);
     delay(1000);}
  for(int i=0;i<6;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(1000);     // 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;  
  return Temp;
 }

Кнопки такиеhttp://ru.aliexpress.com/item/ONPOW-19mm-flat-head-aluminium-anodized-piezo-switch-PS193P10YNT1-CE-RoHS/1741255731.html

 

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

Подскажите. Хотя бы, куда копать?

Disabled
Offline
Зарегистрирован: 07.12.2016

Tazzzz пишет:

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

Кнопки установлены пьезо, типа сенроных, два контакта. Проблема во время работы самостоятельное переключение кнопок, чаще с 1 на 2. Как это можно решить. Спасибо.

 

Ненадо никуда копать и подкапывать. 

Оптореле в помощь. У нас мойка самообслуживания ,мучались 2 года. 

Синие реле = обычные, в помойку, оптореле вместо них. Никаких проблем.