ESP#32 Сканер для вай фай начало,на базе кинга,но экономия на дисплеях ,кнопках,и вообще намного упрощенный вариант)))

Вопросы,пожелания, файлы прошивки, и все что касается Царь-Граббера,спрашивайте не стесняйтесь, я автор и создатель этого сканера)))
Аватар пользователя
admin
Администратор
Сообщений: 154
Зарегистрирован: 10 июн 2017, 16:49
Откуда: Rakun City
Контактная информация:

ESP#32 Сканер для вай фай начало,на базе кинга,но экономия на дисплеях ,кнопках,и вообще намного упрощенный вариант)))

Сообщение admin » 16 апр 2018, 13:34

Свежий ,но не до конца допиленный,основная на есп8266
ESP32-KINGWIFI-LCD-FILE_M2.rar



В стадии доработки,в целом все работает намного бодрее esp8266,но иногда бывают зависания, от низкого скорее всего питания,в целом сырой ,но рабочий код для esp32 8-)

Код: Выбрать все





#include <WiFi.h>
#include <TimeLib.h>
#include <FS.h>
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h>
#include <Preferences.h>



#include <Wire.h>

#include "math.h"

#include <OneWire.h>

Preferences prefs;


unsigned long wait000=0UL,wait001=1000UL;


int Batareya, BatLow = 400; //Контроль напряжения батареи
float Povorot = 0.8, Trimer;    // Переменные для значений поворота и тримера двигателя



const char *ssid = "KING-GRABBER-32";
const char *password = "";


String webSite,javaScript,XML;




String codan ="Scanning begin";


String codan2 ="not code";

String codan1 ="not code";

String sending ="nothing no send";

String button ="";
String gasa="zagasa";

String Bat, SilaW;

int Sila, SilaLow = -43;   // Контроль силы сигнала WiFi

String readString;

////////////////////////////////////////////////////////////////GRABBER///////////////////////////////////////////////////////

int stoppriem=1;
int smena = 1;//smena sig
#define rxPin 13 //d13
#define TX 12 //d12





int ing = 0;
int starlineCounter = 0;
int starlinePreambula = 0;
static long StarLineCode1 = 0; // first part
static long StarLineCode2 = 0; // last part
static long invertStarLineCode1 = 0; // first part
static long invertStarLineCode2 = 0; // last part
String code = "";
boolean bValidPacket=false;
int decodeMethod = 1;
int lastRxValue = 0;
int tempRxValue = 0;
unsigned long lastRxTime = 0;
unsigned long tempTime = 0;
 
//keeloq
int keeloqHeader=0;

int keeloqCounter = 0;

int starlineZCounter = 0;

int starlineZpreambulaCounter = 0;
int keeloqPreambula = 0;

int stralineHeader=0;


static long keeloqCode1 = 0; // first part
static long keeloqCode2 = 0; // last part
static long invertkeeloqCode1 = 0; // first part
static long invertkeeloqCode2 = 0; // last part
String keecode = "";


boolean keebValidPacket=false;

int keelastRxValue = 0;
int keetempRxValue = 0;
unsigned long keelastRxTime = 0;
unsigned long keetempTime = 0;

//пробуем выброс
//keelog start
unsigned long difTime = 0;
unsigned long difTime2 = 0;
int keelog_state = 0;
int keelogCounter = 0;
byte keelog_code[9];
byte keelog_codePAK2[9];
byte keelog_codePAK1[9];
byte hugaz[9];
byte hugazk[9];
byte hugazi[9];
byte starline_code[9];
byte starline_codePAK2[9];
byte starline_codePAK1[9];



byte memkee[30];
byte memsta[30];



byte webpak2[9];
byte webpak1[9];



int starline_state = 0;
byte kefang[9];


byte starline_codePAK2zapis[9];
byte starline_codePAK1zapis[9];

byte starline_codePAK2zapisSBTR[9];
byte starline_codePAK1zapisSBTR[9];


byte keelog_codePAK2zapis[9];
byte keelog_codePAK1zapis[9];


byte keelog_codePAK2zapisSBTR[9];
byte keelog_codePAK1zapisSBTR[9];

byte hugazS[9];
byte hugaziS[9];

byte hugazK[9];
byte hugaziK[9];
//////////joystic

const uint8_t vbatPin = 34;
float VBAT;

 const uint8_t vbatPinY = 35;
float VBATY;


/////////////////////////////////////////////////VVODNIE

byte VVOD1[9];
byte VVOD2[9];


// --------------------
byte CODE[8];
int x=0;

int k=0;//schet keeloq 
int kk  =0; //shet star line

int starkk = 0;






///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



void codanz(){

codan;

 
}


AsyncWebServer server(80);

void setup(){

   prefs.begin("esp32king", false);
   prefs.end();

pinMode(rxPin, INPUT);
//pinMode(buttonvibros,INPUT_PULLUP);


  pinMode(TX, OUTPUT);

  lastRxValue = digitalRead(rxPin);
lastRxTime = micros();

//kee
  keelastRxValue = digitalRead(rxPin);
keelastRxTime = micros();
///  delay(100);
/// Serial.println("start KING-GRAB ");
 
  Serial.begin(115200);

  WiFi.softAP(ssid, password);

  Serial.println();
  Serial.print("IP address: ");
  Serial.println(WiFi.softAPIP());
    buildXML();
 buildJavascript();
 buildWebsite();
/////////////////////////////////////////////////////////////////////////////SOKETS////////////////////////////////////////////////
 server.on("/socket1On", HTTP_GET, [](AsyncWebServerRequest *request){

   
   //// request->send(200, "text/html",webSite );
       posilkeeloq1();
        request->send(200, "text/html",webSite );
  });

 server.on("/socket1Off", HTTP_GET, [](AsyncWebServerRequest *request){

     
    ////request->send(200, "text/html",webSite );
       posilkeeloq2();
        request->send(200, "text/html",webSite );
  });


server.on("/socket2On", HTTP_GET, [](AsyncWebServerRequest *request){

   
   ////  request->send(200, "text/html",webSite );
     posilstarline1();
      request->send(200, "text/html",webSite );
  });

 server.on("/socket2Off", HTTP_GET, [](AsyncWebServerRequest *request){

   ////  request->send(200, "text/html",webSite );
   posilstarline2();
    request->send(200, "text/html",webSite );
  });



server.on("/socket3On", HTTP_GET, [](AsyncWebServerRequest *request){

   
  //// request->send(200, "text/html",webSite );
  stoppriem = 1;
   request->send(200, "text/html",webSite );
  });

 server.on("/socket3Off", HTTP_GET, [](AsyncWebServerRequest *request){

   
    //// request->send(200, "text/html",webSite );
   stoppriem = 0;
    request->send(200, "text/html",webSite );
  });






 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

   server.on("/xml", HTTP_GET, [](AsyncWebServerRequest *request){

     request->send(200,"text/xml",XML);
  });



  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send(200, "text/html",webSite );
    //// request->send(200,"text/xml",XML);
  });


     server.on("/xml", HTTP_PUT, [](AsyncWebServerRequest *request){

     request->send(200,"text/xml",XML);
  });



  server.on("/", HTTP_PUT, [](AsyncWebServerRequest *request){
    request->send(200, "text/html",webSite );
    //// request->send(200,"text/xml",XML);
  });

   server.on("/xml", HTTP_POST, [](AsyncWebServerRequest *request){

     request->send(200,"text/xml",XML);
  });



  server.on("/", HTTP_POST, [](AsyncWebServerRequest *request){
    request->send(200, "text/html",webSite );
    //// request->send(200,"text/xml",XML);
  });

   server.on("/xml", HTTP_ANY, [](AsyncWebServerRequest *request){

     request->send(200,"text/xml",XML);
  });



  server.on("/", HTTP_ANY, [](AsyncWebServerRequest *request){
    request->send(200, "text/html",webSite );
    //// request->send(200,"text/xml",XML);
  });


   
  server.begin();
}

void loop(){
 
 
   if(millis()>wait000){
    buildXML();
    wait000=millis()+1000UL;
  }
  if(millis()>wait001){
    wait001=millis()+300;           //Обновляем значения раз в 300 милисекунд

 
 }
 
 if(stoppriem==1){
 
  startgrabber();}
 
  }


String millis2time(){ // преобразование милисекунд в вид ч/м/с
  String Time="";
  unsigned long ss;
  byte mm,hh;
  ss=millis()/1000;
  hh=ss/3600;
  mm=(ss-hh*3600)/60;
  ss=(ss-hh*3600)-mm*60;
  if(hh<10)Time+="0";
  Time+=(String)hh+":";
  if(mm<10)Time+="0";
  Time+=(String)mm+":";
  if(ss<10)Time+="0";
  Time+=(String)ss;
  return Time;
}



void buildXML(){
  XML="<?xml version='1.0'?>";
  XML+="<xml>";
  XML+="<millistime>";
  XML+=millis2time();
  XML+="</millistime>";   // Добавляем наши данные
              // Здесь измеряем силу сигнала
  XML+="<Sila>";          // Сила сигнала WiFi
  XML+=String(Sila)+SilaW;// Сила сигнала WiFi
  XML+="</Sila>";         // Сила сигнала WiFi

   codanz();
 ///  startgrabber(); ////code
  XML+="<Batareya>";       
 ////XML+="<br>";
   XML+=String(codan);
  XML+="</Batareya>";




     
    XML+="<Paket>";       
   XML+=String(codan2);
  XML+="</Paket>";   


       XML+="<Paket1>";       
   XML+=String(codan1);
  XML+="</Paket1>";   



    XML+="<button>";         

   XML+=String(button)+"button send";
  XML+="</button>";       

    XML+="<button2>";         

   XML+=String(button)+"button send";
  XML+="</button2>";         




    XML+="<sending>";         

   XML+=String(sending);
   
  XML+="</sending>";         
 
  XML+="</xml>";
}













void handleXML(){
  buildXML();
 ///// server.send(200,"text/xml",XML);

   
}





void buildWebsite(){    // Создаём страницу с элементами управления
  buildJavascript();
  webSite="<!DOCTYPE HTML>\n";
  webSite+="<META name='viewport' content='width=device-width, initial-scale=1', charset=\"utf-8\">\n";
   webSite+="<link rel='shortcut icon' type='image/x-icon' href='http://gansta-paradise.com/favicon.ico'>";

      webSite+="<style> #Paket{color:green}button{border: solid;border-radius: 300px;border-color: green;font-size: 15px;font-family: -webkit-pictograph;background: #d5e0d3;}</style>";
  webSite+=javaScript;
  webSite+="<BODY onload='process()'>\n";
  webSite+="WifiScaner\n<br>";
  webSite+="Время работы = <A ID='runtime'></A>\n<br>";
  webSite+="Сила сигнала <A ID='Sila'></A>\n<br>";              // Сила сигнала WiFi
  webSite+="CodeGrabing<br> <A ID='Batareya'></A>\n<br>"; // Напряжение батареи
   webSite+="Пакет2:<A ID='Paket'></A>\n<br>"; // Напряжение батареи
    webSite+="Пакет1:<A ID='Paket1'></A>\n<br>"; // Напряжение батареи
  webSite+="<TABLE BORDER=1 width='700' height='100' style='text-align:center;border-collapse:collapse'>\n";
  //  webSite+="<INPUT ' TYPE='range' width='600'> \n";  // это пример слайдера

   webSite+="<button id='button' onclick='doFunction();'>Send code\n";
        webSite+="</button>\n<br>";
  webSite+="</TABLE>\n";
 

            webSite+="<div id='sending'>\n";

              webSite+="</div>\n";

        webSite+="<p>OTPRAVITI COD STARLINE  <a href=\"socket2On\"><button>PAK1</button></a>&nbsp;<a href=\"socket2Off\"><button>PAK2</button></a></p><br>";
         webSite+="<p>OTPRAVITI COD KEELOQ  <a href=\"socket1On\"><button>PAK1</button></a>&nbsp;<a href=\"socket1Off\"><button>PAK2</button></a></p><br>";

          webSite+="<p>PRIEM  <a href=\"socket3On\"><button>ON</button></a>&nbsp;<a href=\"socket3Off\"><button>OFF</button></a></p><br>";
  webSite+="</BODY>\n";
  webSite+="</HTML>\n";
}



void buildJavascript(){
  javaScript="<SCRIPT>\n";
  javaScript+="xmlHttp=createXmlHttpObject();\n";
 
  javaScript+="function createXmlHttpObject(){\n";
  javaScript+="  if(window.XMLHttpRequest){\n";
  javaScript+="    xmlHttp=new XMLHttpRequest();\n";
  javaScript+="  }else{\n";
  javaScript+="    xmlHttp=new ActiveXObject('Microsoft.XMLHTTP');\n";
  javaScript+="  }\n";
  javaScript+="  return xmlHttp;\n";
  javaScript+="}\n";
 
  javaScript+="function process(){\n";
  javaScript+="  if(xmlHttp.readyState==0||xmlHttp.readyState==4){\n";
  javaScript+="    xmlHttp.onreadystatechange=function(){\n";
  javaScript+="      if(xmlHttp.readyState==4&&xmlHttp.status==200){\n";
  javaScript+="        xmlDoc=xmlHttp.responseXML;\n";
  javaScript+="        xmlmsg=xmlDoc.getElementsByTagName('millistime')[0].firstChild.nodeValue;\n";
  javaScript+="        document.getElementById('runtime').innerHTML=xmlmsg;\n";               // Добавляем наши данные
  javaScript+="        xmlmsg=xmlDoc.getElementsByTagName('Sila')[0].firstChild.nodeValue;\n";// Сила сигнала WiFi
  javaScript+="        document.getElementById('Sila').innerHTML=xmlmsg;\n";                  // Сила сигнала WiFi
  javaScript+="        xmlmsg=xmlDoc.getElementsByTagName('Batareya')[0].firstChild.nodeValue;\n";// Напряжение батареи
  javaScript+="        document.getElementById('Batareya').innerHTML=xmlmsg;\n";                  // Напряжение батареи





   javaScript+="        xmlmsg=xmlDoc.getElementsByTagName('sending')[0].firstChild.nodeValue;\n";//
  javaScript+="        document.getElementById('sending').innerHTML=xmlmsg;\n";                  // посылка кода

   javaScript+="        xmlmsg=xmlDoc.getElementsByTagName('Paket')[0].firstChild.nodeValue;\n";
  javaScript+="        document.getElementById('Paket').innerHTML=xmlmsg;\n";     

   javaScript+="        xmlmsg=xmlDoc.getElementsByTagName('Paket1')[0].firstChild.nodeValue;\n";
  javaScript+="        document.getElementById('Paket1').innerHTML=xmlmsg;\n";   


 javaScript+="        xmlmsg=xmlDoc.getElementsByTagName('button')[0].firstChild.nodeValue;\n";// knop
 javaScript+="        document.getElementById('button').innerHTML=xmlmsg;\n";                  // knop

javaScript+="   document.getElementById('button').onclick = function (button) { alert('Сюрприз!');" ;
 javaScript+="  var button =1; if (button==1){alert('Пошел на хуй');button++;alert(button);} };";
 
  javaScript+="      }\n";
  javaScript+="    }\n";
  javaScript+="    xmlHttp.open('PUT','xml',true);\n";
  javaScript+="    xmlHttp.send(null);\n";
  javaScript+="  }\n";
  javaScript+="  setTimeout('process()',100);\n";
  javaScript+="}\n";



 
 
  javaScript+="</SCRIPT>\n";




}











/////////////////////////////////////////////////////////////////GRABBER_FUNCTIONS//////////////////////////////////////////////



//keeloq////////////////////////////////////////////////KEEEEEEEEEEEEEEELOOOOQ//////////////////////////////////////////////////////////////////////////
void keelog_vardump(){
  if(decodeMethod == 0){
    Serial.println(" - keelog origin - ");
  }
  else{
    Serial.println(" - keelog invert - ");
  }
  Serial.print(keelog_code[0], HEX);
  Serial.print(keelog_code[1], HEX);
  Serial.print(keelog_code[2], HEX);
  Serial.print(keelog_code[3], HEX);
  Serial.println("-hop");
  Serial.print(keelog_code[4], HEX);
  Serial.print(keelog_code[5], HEX);
  Serial.print(keelog_code[6], HEX);
  Serial.println("-fix");
  Serial.print(keelog_code[7], HEX);
  Serial.println("-btn");
  Serial.print(keelog_code[8], HEX);
  Serial.println("-dop");

 
codan="code keqloq:"+String(keelog_code[0],HEX);
codan=codan+String(keelog_code[1],HEX);
codan=codan+String(keelog_code[2],HEX);
codan=codan+String(keelog_code[3],HEX);
codan=codan+"-hop-";
codan=codan+String(keelog_code[4],HEX);
codan=codan+String(keelog_code[5],HEX);
codan=codan+String(keelog_code[6],HEX);
codan=codan+"-fix-";
codan=codan+String(keelog_code[7],HEX);
codan=codan+"-btn-";
codan=codan+String(keelog_code[8],HEX);

Serial.println(codan);
 
///glushilka();////////////////////////glushilka
  smena = 10;
 

 ///////display.clearDisplay();

/////////delay(10);
  /////////display.setTextColor(WHITE);
//////  display.setCursor(0,0);
 ///// display.setTextSize(1);
 ////////////// display.println("invertkeeloqCode");

 ////////////// display.setTextSize(1.5);
////////////////  display.print(keelog_code[0], HEX);
///////////////////  display.print(keelog_code[1], HEX);
////////////  display.print(keelog_code[2], HEX);
 ////////// display.print(keelog_code[3], HEX);
 ///////////   display.println("-hop");
 /////////////     display.print(keelog_code[4], HEX);
 //////////// display.print(keelog_code[5], HEX);
///////////  display.print(keelog_code[6], HEX);
////////////////    display.println("-fix");   
///////////  display.print(keelog_code[7], HEX); 
///////////////    display.println("-btn");
///////////////     display.print(keelog_code[8], HEX); 
//////////////    display.println("-dop");
//////////////    display.println(k);
/////////////    delay(10);

   
  //////////////    display.display();


     
 
  //eprom
 //  EEPROM.begin(3512);



 prefs.begin("esp32king", false);


 if(k<2){
 
 // EEPROM.begin(3512);
//  EEPROM.write(0, keelog_code[0]);


prefs.putUChar("kee0",  keelog_code[0]);
prefs.putUChar("kee1",  keelog_code[1]);
prefs.putUChar("kee2",  keelog_code[2]);
prefs.putUChar("kee3",  keelog_code[3]);
prefs.putUChar("kee4",  keelog_code[4]);
prefs.putUChar("kee5",  keelog_code[5]);
prefs.putUChar("kee6",  keelog_code[6]);
prefs.putUChar("kee7",  keelog_code[7]);
prefs.putUChar("kee8",  keelog_code[8]);
//    EEPROM.write(1,keelog_code[1]);
 //    EEPROM.write(2,keelog_code[2]);
 //    EEPROM.write(3,keelog_code[3]);
 //    EEPROM.write(4,keelog_code[4]);///fix
  ///  EEPROM.write(5,keelog_code[5]);///fix
  //  EEPROM.write(6,keelog_code[6]);//fix
  //   EEPROM.write(7,keelog_code[7]);
  //  EEPROM.write(8,keelog_code[8]);
 ///     EEPROM.commit();
  //    EEPROM.end();



  codan1="code keqloq:"+String(prefs.getUChar("kee0", 0),HEX);
codan1=codan1+String(prefs.getUChar("kee1", 0),HEX);
codan1=codan1+String(prefs.getUChar("kee2", 0),HEX);
codan1=codan1+String(prefs.getUChar("kee3", 0),HEX);
codan1=codan1+"-hop-";
codan1=codan1+String(prefs.getUChar("kee4", 0),HEX);
codan1=codan1+String(prefs.getUChar("kee5", 0),HEX);
codan1=codan1+String(prefs.getUChar("kee6", 0),HEX);
codan1=codan1+"-fix-";
codan1=codan1+String(prefs.getUChar("kee7", 0),HEX);
codan1=codan1+"-btn-";
codan1=codan1+String(prefs.getUChar("kee8", 0),HEX);

 
     k ++;   
     prefs.end();
  }
 

     
if(k>=2){
    prefs.begin("esp32king", false);
//  EEPROM.begin(3512);
//  EEPROM.write(9,keelog_code[4]);///fix1bit
prefs.putUChar("kee9",  keelog_code[4]);
//  EEPROM.write(19,keelog_code[0]);//hop 1bit
prefs.putUChar("kee19",  keelog_code[0]);

 //   EEPROM.write(41,keelog_code[5]);//fix5
 prefs.putUChar("kee41",  keelog_code[5]);
 //    EEPROM.write(43,keelog_code[6]);//fix6
 prefs.putUChar("kee43",  keelog_code[6]);

  //   EEPROM.write(42,keelog_code[1]);//hop 2bit
  prefs.putUChar("kee42",  keelog_code[1]);
 //     EEPROM.commit();
 // EEPROM.end();
       
///EEPROM.begin(3512);
  int hugaK = prefs.getUChar("kee4", 0);//sravnenie bitovfix-- 1bit(4)
 
 int hugaopK = prefs.getUChar("kee9", 0);//sravnenie bitovfix 1bit (4)

int tashigipidr = prefs.getUChar("kee6",0);///fix6
    int tashigipidr2 =prefs.getUChar("kee43",0);/////fix6



    int hugazioK = prefs.getUChar("kee5", 0);//fix5
      int hugazioKk = prefs.getUChar("kee41", 0);//fix5

   
    int hugazioopKch = prefs.getUChar("kee0", 0);//1bit 1 pak

     int hugaKopzzch = prefs.getUChar("kee19", 0);

     int hugazioKoip = prefs.getUChar("kee6", 0);//первый бит
     int hugazioKoiip = prefs.getUChar("kee43", 0);




int hugazioKkz = prefs.getUChar("kee41", 0);//fix5
      int hugazioKkkz =  prefs.getUChar("kee5", 0);//fix5

      int tashigi =  prefs.getUChar("kee41", 0);//fix5
      int tashigi2 =  prefs.getUChar("kee5", 0);//fix5

 int tashigi3 =  prefs.getUChar("kee41", 0);//fix5
      int tashigi4 =  prefs.getUChar("kee5", 0);//fix5
      prefs.end();


if(hugaK!=hugaopK&&hugazioK!=hugazioKk&&tashigipidr!=tashigipidr2){

  k = 0;
}
     

if(hugaK==hugaopK&&hugazioK==hugazioKk&&tashigipidr==tashigipidr2&&hugazioopKch!=hugaKopzzch)///////////////hop  srav&&hugazioKoiip!=hugazioKoip &&hugaKop!=hugazioopK
{
  prefs.begin("esp32king", false);

 // EEPROM.begin(3512);
//EEPROM.write(10, keelog_code[0]);
prefs.putUChar("kee10",  keelog_code[0]);
//EEPROM.write(11,keelog_code[1]);
prefs.putUChar("kee11",  keelog_code[1]);
//EEPROM.write(12,keelog_code[2]);
prefs.putUChar("kee12",  keelog_code[2]);
//EEPROM.write(13,keelog_code[3]);
prefs.putUChar("kee13",  keelog_code[3]);
//.write(14,keelog_code[4]);
prefs.putUChar("kee14",  keelog_code[4]);
//EEPROM.write(15,keelog_code[5]);
prefs.putUChar("kee15",  keelog_code[5]);
//EEPROM.write(16,keelog_code[6]);
prefs.putUChar("kee16",  keelog_code[6]);
//EEPROM.write(17,keelog_code[7]);
prefs.putUChar("kee17",  keelog_code[7]);
//EEPROM.write(18,keelog_code[8]);
prefs.putUChar("kee18",  keelog_code[8]);
//  EEPROM.commit();
 // EEPROM.end();
  k = 0;

 
 
codan2="";
stoppriem = 0;


            int zilk=0;
    for(int i = 10; i<19; i++){

   //   EEPROM.begin(3512);
     

     hugazk[0] =prefs.getUChar("kee10", 0);
      hugazk[1] =prefs.getUChar("kee11", 0);
       hugazk[2] =prefs.getUChar("kee12", 0);
        hugazk[3] =prefs.getUChar("kee13", 0);
         hugazk[4] =prefs.getUChar("kee14", 0);
          hugazk[5] =prefs.getUChar("kee15", 0);
           hugazk[6] =prefs.getUChar("kee16", 0);
            hugazk[7] =prefs.getUChar("kee17", 0);
             hugazk[8] =prefs.getUChar("kee18", 0);
   
///     display.print(hugazk[zilk],HEX);
///      delay(3);
     
 ////     display.display();
 codan2=codan2+String(hugazk[zilk],HEX);
     
     zilk++;
  }
  prefs.end();
}




if(hugazioKkz==hugazioKkkz&&tashigi==tashigi2&&tashigi3==tashigi4){

///  display.println();
///display.println("one pack sig");
//// display.display();
//k = 0;
 
}

  }



  prefs.begin("esp32king", false);
 
///EEPROM.begin(3512);

keelog_codePAK2[0]=prefs.getUChar("kee10", 0);
keelog_codePAK2[1]=prefs.getUChar("kee11", 0);
 keelog_codePAK2[2]=prefs.getUChar("kee12", 0);
keelog_codePAK2[3]=prefs.getUChar("kee13", 0);
 keelog_codePAK2[4]=prefs.getUChar("kee14", 0);
 keelog_codePAK2[5]=prefs.getUChar("kee15", 0);
 keelog_codePAK2[6]=prefs.getUChar("kee16", 0);;
 keelog_codePAK2[7]=prefs.getUChar("kee17", 0);
keelog_codePAK2[8]=prefs.getUChar("kee18", 0);
//   EEPROM.commit();
 // EEPROM.end();


 // EEPROM.begin(3512);

 keelog_codePAK1[0]=prefs.getUChar("kee0", 0);
keelog_codePAK1[1]=prefs.getUChar("kee1", 0);
 keelog_codePAK1[2]=prefs.getUChar("kee2", 0);
 keelog_codePAK1[3]=prefs.getUChar("kee3", 0);
  keelog_codePAK1[4]=prefs.getUChar("kee4", 0);
keelog_codePAK1[5]=prefs.getUChar("kee5", 0);
 keelog_codePAK1[6]=prefs.getUChar("kee6", 0);
 keelog_codePAK1[7]=prefs.getUChar("kee7", 0);
 keelog_codePAK1[8]=prefs.getUChar("kee8", 0);
//   EEPROM.commit();
 // EEPROM.end();
 prefs.end();
}
void keelog_send(byte* keelog_code){
  Serial.println("- sending keelog -");
  for(int i = 0; i<9; i++){
    Serial.print(keelog_code[i], HEX);
    Serial.print(" - ");
  }
  for(int i = 0; i<11; i++){//посылаем преамблу
    send_meander(400);
  }
  digitalWrite(TX, HIGH);
  delayMicroseconds(400);
  digitalWrite(TX, LOW);
  delayMicroseconds(4000);//посылаем хедер
 
  for( int i = 0; i<9; i++){
    if(decodeMethod==1){
      for(int i2 = 7;i2>=0;i2--){
        if(bitRead(keelog_code[i], i2)){
          digitalWrite(TX, HIGH);
          delayMicroseconds(400);
          digitalWrite(TX, LOW);
          delayMicroseconds(2*400);
        }
        else{
          digitalWrite(TX, HIGH);
          delayMicroseconds(2*400);
          digitalWrite(TX, LOW);
          delayMicroseconds(400);
        }
      }
    }
    else{
        for(int i2 = 0;i2<8;i2++){
          if(!bitRead(keelog_code[i], i2)){
            digitalWrite(TX, HIGH);
            delayMicroseconds(400);
            digitalWrite(TX, LOW);
            delayMicroseconds(2*400);
          }
          else{
            digitalWrite(TX, HIGH);
            delayMicroseconds(2*400);
            digitalWrite(TX, LOW);
            delayMicroseconds(400);
          }
       }
    }
   
  }
}








//pak2


void keelog_sendPAK2(byte* keelog_codePAK2){
  Serial.println("- sending keelog -ss-");
  for(int i = 0; i<9; i++){
    Serial.print(keelog_codePAK2[i], HEX);
    Serial.print(" -zz ");
  }
  for(int i = 0; i<11; i++){//посылаем преамблу
    send_meander(400);
  }
  digitalWrite(TX, HIGH);
  delayMicroseconds(400);
  digitalWrite(TX, LOW);
  delayMicroseconds(4000);//посылаем хедер
 
  for( int i = 0; i<9; i++){
    if(decodeMethod==1){
      for(int i2 = 7;i2>=0;i2--){
        if(bitRead(keelog_codePAK2[i], i2)){
          digitalWrite(TX, HIGH);
          delayMicroseconds(400);
          digitalWrite(TX, LOW);
          delayMicroseconds(2*400);
        }
        else{
          digitalWrite(TX, HIGH);
          delayMicroseconds(2*400);
          digitalWrite(TX, LOW);
          delayMicroseconds(400);
        }
      }
    }
    else{
        for(int i2 = 0;i2<8;i2++){
          if(!bitRead(keelog_codePAK2[i], i2)){
            digitalWrite(TX, HIGH);
            delayMicroseconds(400);
            digitalWrite(TX, LOW);
            delayMicroseconds(2*400);
          }
          else{
            digitalWrite(TX, HIGH);
            delayMicroseconds(2*400);
            digitalWrite(TX, LOW);
            delayMicroseconds(400);
          }
       }
    }
   
  }
}






void keelog_get(){
    bValidPacket = false;
    if(keelog_state==0){//ждем преамбулу и хедер
      if(difTime > 280 && difTime < 620 && lastRxValue != tempRxValue){
        keelogCounter ++;
      }
      else{
        if(keelogCounter==23){
          if(difTime>2800 && difTime<6200 && lastRxValue == 0){
            keelog_state=1;
          }
        }
       keelogCounter = 0;
      }
    }
    else if(keelog_state==1){// получаем биты
      if(difTime > 560 && difTime < 1240 && lastRxValue == 1){// получили 1
        if(decodeMethod==0){
          keelog_code[round(keelogCounter/8)] = (keelog_code[round(keelogCounter/8)]>>1)|B10000000;
        }
        else{
          keelog_code[round(keelogCounter/8)] = (keelog_code[round(keelogCounter/8)]<<1)|B00000000;
        }
        bValidPacket = true;
      }
      else if(difTime > 280 && difTime < 620 && lastRxValue == 1){
        if(decodeMethod==0){
          keelog_code[round(keelogCounter/8)] = (keelog_code[round(keelogCounter/8)]>>1)|B00000000;
        }
        else{
          keelog_code[round(keelogCounter/8)] = (keelog_code[round(keelogCounter/8)]<<1)|B00000001;
        }
        bValidPacket = true;
      }
      else if(lastRxValue == 0){
      }
      else{
        keelog_state=1;
        keelogCounter = 0;
      }
     
      if(bValidPacket){
        keelogCounter++;
        if(keelogCounter==66){
          keelog_vardump();
          keelogCounter = 0;
          keelog_state = 0;
         ///////  glushilka();
         
       
        }
      }
    }
}
//keelog end



///uuuaaaaaaaa che ya nadelal)))))))) IIIIIIzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzSTAAAAAAAAAAAAAAAAARRRRRRRRRRzzzzzzz


//statline pomba
void starline_vardump(){
  if(decodeMethod == 0){
    Serial.println(" - starline origin - ");
  }
  else{
    Serial.println(" - starline invert - ");
  }

 
  Serial.print(starline_code[0], HEX);
  Serial.print(starline_code[1], HEX);
  Serial.print(starline_code[2], HEX);
  Serial.print(starline_code[3], HEX);
  Serial.println("-hop");
  Serial.print(starline_code[4], HEX);
  Serial.print(starline_code[5], HEX);
  Serial.print(starline_code[6], HEX);
  Serial.println("-fix");
  Serial.print(starline_code[7], HEX);
  Serial.println("-btn");
  Serial.print(starline_code[8], HEX);
  Serial.println("-dop");

///proda vibrosaaaaaaaaaaaaaaaa



 
codan="code starline:"+String(starline_code[0],HEX);
codan=codan+String(starline_code[1],HEX);
codan=codan+String(starline_code[2],HEX);
codan=codan+String(starline_code[3],HEX);
codan=codan+"-hop-";
codan=codan+String(starline_code[4],HEX);
codan=codan+String(starline_code[5],HEX);
codan=codan+String(starline_code[6],HEX);
codan=codan+"-fix-";
codan=codan+String(starline_code[7],HEX);
codan=codan+"-btn-";
codan=codan+String(starline_code[8],HEX);

Serial.println(codan);



///proda vibrosaaaaaaaaaaaaaaaa



 


 
  smena = 1;



///* display.clearDisplay();

////delay(3);/
////  display.setTextColor(WHITE);
/////  display.setCursor(0,0);
///////  display.setTextSize(1);
///////  display.println("invertstarlineCode");

 ////////// display.setTextSize(1.5);
 /////////// display.print(starline_code[0], HEX);
 ///////// display.print(starline_code[1], HEX);
 //////// display.print(starline_code[2], HEX);
 /////// display.print(starline_code[3], HEX);
  //////  display.println("-hop");
    //////  display.print(starline_code[4], HEX);
 /////// display.print(starline_code[5], HEX);
 ///////// display.print(starline_code[6], HEX);
 ////////   display.println("-fix");   
///////  display.print(starline_code[7], HEX); 
  ////////  display.println("-btn");
  ////////   display.print(starline_code[8], HEX); 
 ////////   display.println("-dop");
  ////////  display.println(kk);//////////////////////////otladka
 //////   delay(10);
   
   /////////////   display.display();
////






 
     
 
  //eprom
 //  EEPROM.begin(3512);


 prefs.begin("esp32king", false);


 if(kk<2){
///EEPROM.begin(3512);
 prefs.putUChar("sta0",starline_code[0]);
 // EEPROM.write(20, starline_code[0]);
  prefs.putUChar("sta1",starline_code[1]);
 //   EEPROM.write(21,starline_code[1]);
  prefs.putUChar("sta2",starline_code[2]);
 
 ///    EEPROM.write(22,starline_code[2]);
  prefs.putUChar("sta3",starline_code[3]);
 ///    EEPROM.write(23,starline_code[3]);
  prefs.putUChar("sta4",starline_code[4]);
 ///    EEPROM.write(24,starline_code[4]);
  prefs.putUChar("sta5",starline_code[5]);
  ///  EEPROM.write(25,starline_code[5]);
   prefs.putUChar("sta6",starline_code[6]);
  ///  EEPROM.write(26,starline_code[6]);
   prefs.putUChar("sta7",starline_code[7]);
 //    EEPROM.write(27,starline_code[7]);
  prefs.putUChar("sta8",starline_code[8]);
  ///  EEPROM.write(28,starline_code[8]);







 codan1="code starline:"+String(prefs.getUChar("sta0",0),HEX);
codan1=codan1+String(prefs.getUChar("sta1",0),HEX);
codan1=codan1+String(prefs.getUChar("sta2",0),HEX);
codan1=codan1+String(prefs.getUChar("sta3",0),HEX);
codan1=codan1+"-hop-";
codan1=codan1+String(prefs.getUChar("sta4",0),HEX);
codan1=codan1+String(prefs.getUChar("sta5",0),HEX);
codan1=codan1+String(prefs.getUChar("sta6",0),HEX);
codan1=codan1+"-fix-";
codan1=codan1+String(prefs.getUChar("sta7",0),HEX);
codan1=codan1+"-btn-";
codan1=codan1+String(prefs.getUChar("sta8",0),HEX);
    prefs.end();
    //  EEPROM.commit();
    //  EEPROM.end();
      kk = 2;
     }
     





if(kk>=2){


 prefs.begin("esp32king", false);

///EEPROM.begin(3512);

 //EEPROM.write(129,starline_code[0]);////gop 3
  prefs.putUChar("sta129",starline_code[0]);
  // Serial.println("-Srab");

  ///////////////////////////////////////////////zapis sverki fix

// EEPROM.write(104,starline_code[4]);
 prefs.putUChar("sta104",starline_code[4]);
 //   EEPROM.write(105,starline_code[5]);
  prefs.putUChar("sta105",starline_code[5]);
 //   EEPROM.write(106,starline_code[6]);
  prefs.putUChar("sta106",starline_code[6]);
//    EEPROM.write(100, starline_code[0]);
   prefs.putUChar("sta100",starline_code[0]);
  // EEPROM.commit();
  //  EEPROM.end();


   
///EEPROM.begin(3512);
 int hugaS = prefs.getUChar("sta5",0);//sravnenie bitov-FIX-5
   int hugazioS = prefs.getUChar("sta105",0);//bitov-FIX-5
    int hugaopS =  prefs.getUChar("sta4",0);;//sravnenie bitovbitov-FIX-4
    int hugazioopS =  prefs.getUChar("sta104",0);;//bitov-FIX-4
        int hugaopSA =  prefs.getUChar("sta6",0);;//sbitov-FIX-6
    int hugazioopSA =  prefs.getUChar("sta106",0);;//bitov-FIX-6







   


     int hugaS1bit =  prefs.getUChar("sta129",0);//sravnenie gop 3
     int hugazioS1bit =  prefs.getUChar("sta0",0);;//gop 3

prefs.end();
   
 // int huga = EEPROM.read(0);//sravnenie bitov
 //  int hugazio = starline_code[0];//
int zyS=29;


  if(hugaS==hugazioS&&hugaopS==hugazioopS&&hugaopSA==hugazioopSA&&hugaS1bit!=hugazioS1bit)//////////////&&hugaS1bit!=hugazioS1bit//////&&hugaS1bit!=hugazioS1bit hop srav
  {

///EEPROM.begin(3512);
 prefs.begin("esp32king", false);

 // EEPROM.write(30, starline_code[0]);
  prefs.putUChar("sta10",starline_code[0]);
 //   EEPROM.write(31,starline_code[1]);
  prefs.putUChar("sta11",starline_code[1]);
  //   EEPROM.write(32,starline_code[2]);
   prefs.putUChar("sta12",starline_code[2]);
  //   EEPROM.write(33,starline_code[3]);
   prefs.putUChar("sta13",starline_code[3]);
  //   EEPROM.write(34,starline_code[4]);
   prefs.putUChar("sta14",starline_code[4]);
  //  EEPROM.write(35,starline_code[5]);
   prefs.putUChar("sta15",starline_code[5]);
   // EEPROM.write(36,starline_code[6]);
    prefs.putUChar("sta16",starline_code[6]);
    // EEPROM.write(37,starline_code[7]);
     prefs.putUChar("sta17",starline_code[7]);
   // EEPROM.write(38,starline_code[8]);
    prefs.putUChar("sta18",starline_code[8]);
    //  EEPROM.commit();
    //  EEPROM.end();



   codan2="";
    stoppriem = 0;
   
  kk = 0;
    int zil=0;
    for(int i = 30; i<39; i++){
     
//EEPROM.begin(3512);
      hugaz[0] = prefs.getUChar("sta10", 0);
        hugaz[1] = prefs.getUChar("sta11", 0);
          hugaz[2] = prefs.getUChar("sta12", 0);
            hugaz[3] = prefs.getUChar("sta13", 0);
              hugaz[4] = prefs.getUChar("sta14", 0);
                hugaz[5] = prefs.getUChar("sta15", 0);
                  hugaz[6] = prefs.getUChar("sta16", 0);
                    hugaz[7] = prefs.getUChar("sta17", 0);
                      hugaz[8] = prefs.getUChar("sta18", 0);
   
  ////   display.print(hugaz[zil],HEX);
  ///    delay(3);
     
   ///   display.display();
     
       codan2=codan2+String(hugaz[zil],HEX);
       zil++;
     
  }
  prefs.end();

  }//proverennaya
 prefs.begin("esp32king", false);

int hugazioS1bit30 = prefs.getUChar("sta10", 0);
prefs.end();

  if(hugaS==hugazioS&&hugaopS==hugazioopS&&hugaopSA==hugazioopSA&&hugaS1bit==hugazioS1bit30) {

kk = 0;
/////glushilka();
   
  }


  if(hugaS!=hugazioS&&hugaopS!=hugazioopS&&hugaopSA!=hugazioopSA) {

kk = 0;
////glushilka();
   
  }



   
}
     
     
 
 

 prefs.begin("esp32king", false);


     int huga4S =prefs.getUChar("sta4", 0);
             int huga44S =prefs.getUChar("sta14", 0);
//
//
            int huga4Skop =prefs.getUChar("sta5", 0);
              int huga44Skop =prefs.getUChar("sta15", 0);


prefs.end();
if(huga4S==huga44S&&huga44Skop==huga4Skop){
///     display.println();
///     display.print("one pack sig");
 ///     delay(10);
     
 ////     display.display(); 
         
  } 


//pak2

// for(int li = 10; li<19; li++){
       

//    int i=0;
   
//    keelog_codePAK2[i]=EEPROM.read(li);
   
//     Serial.print(keelog_codePAK2[i],HEX);
//      delay(100);
 //     i++;

       
 //    Serial.print(keelog_codePAK2[i],HEX);
     
       
 prefs.begin("esp32king", false);


 starline_codePAK2[0]=prefs.getUChar("sta10", 0);
 // starline_codePAK2[1]=EEPROM.read(31);
 starline_codePAK2[1]=prefs.getUChar("sta11", 0);
///   starline_codePAK2[2]=EEPROM.read(32);
starline_codePAK2[2]=prefs.getUChar("sta12", 0);
///   starline_codePAK2[3]=EEPROM.read(33);
starline_codePAK2[3]=prefs.getUChar("sta13", 0);
///   starline_codePAK2[4]=EEPROM.read(34);
starline_codePAK2[4]=prefs.getUChar("sta14", 0);
 ///  starline_codePAK2[5]=EEPROM.read(35);
 starline_codePAK2[5]=prefs.getUChar("sta15", 0);
 ///  starline_codePAK2[6]=EEPROM.read(36);
 starline_codePAK2[6]=prefs.getUChar("sta16", 0);
 ////  starline_codePAK2[7]=EEPROM.read(37);
 starline_codePAK2[7]=prefs.getUChar("sta17", 0);
 //  starline_codePAK2[8]=EEPROM.read(38);
 starline_codePAK2[8]=prefs.getUChar("sta18", 0);




  starline_codePAK1[0]=prefs.getUChar("sta0", 0);
 // starline_codePAK2[1]=EEPROM.read(31);
 starline_codePAK1[1]=prefs.getUChar("sta1", 0);
///   starline_codePAK2[2]=EEPROM.read(32);
starline_codePAK1[2]=prefs.getUChar("sta2", 0);
///   starline_codePAK2[3]=EEPROM.read(33);
starline_codePAK1[3]=prefs.getUChar("sta3", 0);
///   starline_codePAK2[4]=EEPROM.read(34);
starline_codePAK1[4]=prefs.getUChar("sta4", 0);
 ///  starline_codePAK2[5]=EEPROM.read(35);
 starline_codePAK1[5]=prefs.getUChar("sta5", 0);
 ///  starline_codePAK2[6]=EEPROM.read(36);
 starline_codePAK1[6]=prefs.getUChar("sta6", 0);
 ////  starline_codePAK2[7]=EEPROM.read(37);
 starline_codePAK1[7]=prefs.getUChar("sta7", 0);
 //  starline_codePAK2[8]=EEPROM.read(38);
 starline_codePAK1[8]=prefs.getUChar("sta8", 0);

prefs.end();
 //for(int i = 0; i<9; i++){
 
       
 //    Serial.println(starline_codePAK2[i],HEX);
//      delay(100);       
 // }

 // int huga =EEPROM.read(0);
//    int huga1 =EEPROM.read(1);
 //    int huga2 =EEPROM.read(2);
 //     int huga3 =EEPROM.read(3);
  //       int huga4 =EEPROM.read(4);
  //          int huga5 =EEPROM.read(5);
   //            int huga6 =EEPROM.read(6);
               
  //                int huga7 =EEPROM.read(7);
 //                    int huga8 =EEPROM.read(8);
 

//  display.setTextColor(WHITE); 
//  display.setTextSize(1);   
//    display.print(huga,HEX);
//     display.print(huga1,HEX);
//     display.print(huga2,HEX);
 //    display.print(huga3,HEX);
//      display.print(huga4,HEX);
//       display.print(huga5,HEX);
//        display.print(huga6,HEX);
//         display.print(huga1,HEX);
//         display.print(huga7,HEX);
//          display.print(huga8,HEX);
//    delay(100);
//    display.display();
   
    //Serial.println(EEPROM.read(0),HEX); // выводим значение в послед. порт
 

 
  //
  /*for(int i = 0; i<9; i++){
    Serial.print(starline_code[i], HEX);
    Serial.print(" - ");
  }*/
//  starline_send(starline_code);
 
//  digitalWrite(TX, HIGH);
//  delay(100);
//  digitalWrite(TX, LOW);
//   starline_sendPAK2(starline_codePAK2);
//  starline_state = 0;
// for(int i = 0; i<9; i++){
//    starline_code[i]=0;
 // }


 
}
void starline_send(byte* starline_code){
  Serial.println("- sending staray -");
  for(int i = 0; i<9; i++){
    Serial.print(starline_code[i], HEX);
    Serial.print(" - ");
  }
  for(int i = 0; i<13; i++){//посылаем преамблу//13 srab
    send_meander(1000);
  }
 // digitalWrite(TX, HIGH);
//  delayMicroseconds(1000);
//  digitalWrite(TX, LOW);
 // delayMicroseconds(4000);//посылаем хедер
 
  for( int i = 0; i<9; i++){
    if(decodeMethod==1){
      for(int i2 = 7;i2>=0;i2--){
        if(bitRead(starline_code[i], i2)){
          digitalWrite(TX, HIGH);
          delayMicroseconds(250);
          digitalWrite(TX, LOW);
          delayMicroseconds(250);
        }
        else{
          digitalWrite(TX, HIGH);
          delayMicroseconds(500);
          digitalWrite(TX, LOW);
          delayMicroseconds(500);
        }
      }
    }
    else{
        for(int i2 = 0;i2<8;i2++){
          if(!bitRead(starline_code[i], i2)){
            digitalWrite(TX, HIGH);
            delayMicroseconds(250);
            digitalWrite(TX, LOW);
            delayMicroseconds(250);
          }
          else{
            digitalWrite(TX, HIGH);
            delayMicroseconds(500);
            digitalWrite(TX, LOW);
            delayMicroseconds(500);
          }
       }
    }
   
  }
}








//pak2


void starline_sendPAK2(byte* starline_codePAK2){
  Serial.println("- sending staraylayn -ss-");
  for(int i = 0; i<9; i++){
    Serial.print(starline_codePAK2[i], HEX);
    Serial.print(" -zz ");
  }
  for(int i = 0; i<13; i++){//посылаем преамблу
    send_meander(1000);
  }
//  digitalWrite(TX, HIGH);
 // delayMicroseconds(400);
//  digitalWrite(TX, LOW);
//  delayMicroseconds(4000);//посылаем хедер
 
  for( int i = 0; i<9; i++){
    if(decodeMethod==1){
      for(int i2 = 7;i2>=0;i2--){
        if(bitRead(starline_codePAK2[i], i2)){
          digitalWrite(TX, HIGH);
          delayMicroseconds(250);
          digitalWrite(TX, LOW);
          delayMicroseconds(250);
        }
        else{
          digitalWrite(TX, HIGH);
          delayMicroseconds(500);
          digitalWrite(TX, LOW);
          delayMicroseconds(500);
        }
      }
    }
    else{
        for(int i2 = 0;i2<8;i2++){
          if(!bitRead(starline_codePAK2[i], i2)){
            digitalWrite(TX, HIGH);
            delayMicroseconds(250);
            digitalWrite(TX, LOW);
            delayMicroseconds(250);
          }
          else{
            digitalWrite(TX, HIGH);
            delayMicroseconds(500);
            digitalWrite(TX, LOW);
            delayMicroseconds(500);
          }
       }
    }
   
  }
}






void starline_get(){
    bValidPacket = false;
    if(starline_state==0){//ждем преамбулу и хедер
      if(difTime2 > 900 && difTime2 < 1100 && lastRxValue ==1 ){
        starlineZpreambulaCounter ++;
       
      }
   

      if(starlineZpreambulaCounter==6){
         
            starline_state=1;         
        }

       //  else{       
     //  starlineZCounter = 0;
     // }
 
    }

    /////////////////////////////////////////////////////PREAMBULA STARA///////////////////////////////////////////////////////////////////////////
    else if(starline_state==1){// получаем биты
      if(difTime2 > 350 && difTime2 < 650 && lastRxValue == 1){// получили 1
        if(decodeMethod==0){
          starline_code[round(starlineZCounter/8)] = (starline_code[round(starlineZCounter/8)]>>1)|B10000000;
        }
        else{
          starline_code[round(starlineZCounter/8)] = (starline_code[round(starlineZCounter/8)]<<1)|B00000000;
        }
        bValidPacket = true;
      }
      else if(difTime2 > 150 && difTime2 < 350 && lastRxValue == 1){
        if(decodeMethod==0){
          starline_code[round(starlineZCounter/8)] = (starline_code[round(starlineZCounter/8)]>>1)|B00000000;
        }
        else{
          starline_code[round(starlineZCounter/8)] = (starline_code[round(starlineZCounter/8)]<<1)|B00000001;
        }
        bValidPacket = true;
      }
      else if(lastRxValue == 0){
      }
      else{
        starline_state=1;
        starlineZCounter = 0;
      }
     
      if(bValidPacket){
        starlineZCounter++;
        if(starlineZCounter==64){           //64ili66
          starline_vardump();
          starlineZCounter = 0;
          starline_state = 0;
          starlineZpreambulaCounter = 0; /////////novshetch
          starkk++;                   /////////shetchik
//////          glushilka();




       
        }
      }
    }
}
//stara end  zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzSSSSTTTTTARRRRRRRRRRRRZZZZZZZZZZZZZZZZzzzzzzzzzzzz


void startgrabber(){






tempRxValue = digitalRead(rxPin);

if(tempRxValue != lastRxValue){
tempTime = micros();
difTime = tempTime - lastRxTime;
difTime2 = tempTime - lastRxTime;
keelog_get();
starline_get();
//grab(tempTime - lastRxTime, lastRxValue);

lastRxTime = tempTime;
lastRxValue = tempRxValue;


 
}
}
 







void send_meander(int time)//pra meandr

{
  digitalWrite(TX, HIGH);
  delayMicroseconds(time);
  digitalWrite(TX, LOW);
  delayMicroseconds(time);
}

void SendStarlinePreambula()
{
  for (byte i=0; i<=10; i++)
    send_meander(1000);
}

void SendStarlineBit(byte b)
{
  if (b)
    send_meander(250); // 1
  else 
    send_meander(500); // 0
}

void SendStarline(unsigned char *TCODE, unsigned int S)
{
  for (int j=0;j<10;j++)                                  // посылку посылаем как и брелок - 10 раз подряд.
  {
    SendStarlinePreambula();                              // посылаем преамбулу
    for (byte i=0;i<S;i++)                                // перебор масива (8 x 8 = 64 bits)
    {
    for (int x=0;x<8;x++){
    SendStarlineBit(!bitRead(TCODE[i], x));               // побитово перебираем, инвертируе и посылаем код
    }
    }
  }
  digitalWrite(TX, HIGH);
}


//////////////////////////////////////////////////POSILKI




void posilkeeloq1(){

 prefs.begin("esp32king", false);

//EEPROM.begin(3512);
// keelog_codePAK1[0]=EEPROM.read(0);
keelog_codePAK1[0]=prefs.getUChar("kee0", 0);

 // keelog_codePAK1[1]=EEPROM.read(1);
 keelog_codePAK1[1]=prefs.getUChar("kee1", 0);
 //  keelog_codePAK1[2]=EEPROM.read(2);
 keelog_codePAK1[2]=prefs.getUChar("kee2", 0);
 //  keelog_codePAK1[3]=EEPROM.read(3);
 keelog_codePAK1[3]=prefs.getUChar("kee3", 0);
 //  keelog_codePAK1[4]=EEPROM.read(4);
 keelog_codePAK1[4]=prefs.getUChar("kee4", 0);
//   keelog_codePAK1[5]=EEPROM.read(5);
keelog_codePAK1[5]=prefs.getUChar("kee5", 0);
//   keelog_codePAK1[6]=EEPROM.read(6);
keelog_codePAK1[6]=prefs.getUChar("kee6", 0);
//   keelog_codePAK1[7]=EEPROM.read(7);
keelog_codePAK1[7]=prefs.getUChar("kee7", 0);
//   keelog_codePAK1[8]=EEPROM.read(8);
keelog_codePAK1[8]=prefs.getUChar("kee8", 0);

prefs.end();
    keelog_send(keelog_codePAK1);
 
  digitalWrite(TX, HIGH);
  delay(100);
  digitalWrite(TX, LOW);



//vibros na displey

sending="code keqloq:"+String( keelog_codePAK1[0],HEX);
sending=sending+String( keelog_codePAK1[1],HEX);
sending=sending+String( keelog_codePAK1[2],HEX);
sending=sending+String( keelog_codePAK1[3],HEX);
sending=sending+String( keelog_codePAK1[4],HEX);
sending=sending+String( keelog_codePAK1[5],HEX);
sending=sending+String( keelog_codePAK1[6],HEX);
sending=sending+String( keelog_codePAK1[7],HEX);
sending=sending+String( keelog_codePAK1[8],HEX);
 
   
  keelog_state = 0;
/// for(int i = 0; i<9; i++){
///    keelog_code[i]=0;}

//Serial.println("srabotalo-keeloq");
   
}


void posilkeeloq2(){
//EEPROM.begin(3512);

 prefs.begin("esp32king", false);

  // keelog_codePAK2[0]=EEPROM.read(10);
  keelog_codePAK2[0]=prefs.getUChar("kee10", 0);
//  keelog_codePAK2[1]=EEPROM.read(11);
  keelog_codePAK2[1]=prefs.getUChar("kee11", 0);
//   keelog_codePAK2[2]=EEPROM.read(12);
  keelog_codePAK2[2]=prefs.getUChar("kee12", 0);
//   keelog_codePAK2[3]=EEPROM.read(13);
  keelog_codePAK2[3]=prefs.getUChar("kee13", 0);
///   keelog_codePAK2[4]=EEPROM.read(14);
  keelog_codePAK2[4]=prefs.getUChar("kee14", 0);
 //  keelog_codePAK2[5]=EEPROM.read(15);
   keelog_codePAK2[5]=prefs.getUChar("kee15", 0);
 //  keelog_codePAK2[6]=EEPROM.read(16);
   keelog_codePAK2[6]=prefs.getUChar("kee16", 0);
 //  keelog_codePAK2[7]=EEPROM.read(17);
   keelog_codePAK2[7]=prefs.getUChar("kee17", 0);
  // keelog_codePAK2[8]=EEPROM.read(18);

prefs.end();

sending="code keqloq:"+String( keelog_codePAK2[0],HEX);
sending=sending+String(keelog_codePAK2[1],HEX);
sending=sending+String(keelog_codePAK2[2],HEX);
sending=sending+String(keelog_codePAK2[3],HEX);
sending=sending+String(keelog_codePAK2[4],HEX);
sending=sending+String(keelog_codePAK2[5],HEX);
sending=sending+String(keelog_codePAK2[6],HEX);
sending=sending+String(keelog_codePAK2[7],HEX);
sending=sending+String(keelog_codePAK2[8],HEX);

   keelog_sendPAK2(keelog_codePAK2);
 digitalWrite(TX, HIGH);
  delay(100);
  digitalWrite(TX, LOW);




 
   
  keelog_state = 0;
/// for(int i = 0; i<9; i++){
///    keelog_codePAK2[i]=0;}
}



void posilstarline1(){


 

  prefs.begin("esp32king", false);
//EEPROM.begin(3512);
 //  starline_codePAK1[0]=EEPROM.read(20);
 starline_codePAK1[0]=  prefs.getUChar("sta0", 0);
 // starline_codePAK1[1]=EEPROM.read(21);
  starline_codePAK1[1]=  prefs.getUChar("sta1", 0);
 //  starline_codePAK1[2]=EEPROM.read(22);
  starline_codePAK1[2]=  prefs.getUChar("sta2", 0);
 //  starline_codePAK1[3]=EEPROM.read(23);
  starline_codePAK1[3]=  prefs.getUChar("sta3", 0);
 //  starline_codePAK1[4]=EEPROM.read(24);
  starline_codePAK1[4]=  prefs.getUChar("sta4", 0);
 //  starline_codePAK1[5]=EEPROM.read(25);
  starline_codePAK1[5]=  prefs.getUChar("sta5", 0);
 //  starline_codePAK1[6]=EEPROM.read(26);
  starline_codePAK1[6]=  prefs.getUChar("sta6", 0);
  // starline_codePAK1[7]=EEPROM.read(27);
   starline_codePAK1[7]=  prefs.getUChar("sta7", 0);
  // starline_codePAK1[8]=EEPROM.read(28);
   starline_codePAK1[8]=  prefs.getUChar("sta8", 0);
prefs.end();
 starline_send(starline_codePAK1);


    sending="code star_line:"+String(   starline_codePAK1[0],HEX);
sending=sending+String(   starline_codePAK1[1],HEX);
sending=sending+String(   starline_codePAK1[2],HEX);
sending=sending+String(   starline_codePAK1[3],HEX);
sending=sending+String(  starline_codePAK1[4],HEX);
sending=sending+String(   starline_codePAK1[5],HEX);
sending=sending+String(  starline_codePAK1[6],HEX);
sending=sending+String(   starline_codePAK1[7],HEX);
sending=sending+String(   starline_codePAK1[8],HEX);

 
  digitalWrite(TX, HIGH);
  delay(100);
  digitalWrite(TX, LOW);



  //vibros na displey

 
  starline_state = 0;
// for(int i = 0; i<9; i++){
 //   starline_code[i]=0;
//  }
 
///  Serial.println("srabotalo");
  }


  void posilstarline2(){
   
 prefs.begin("esp32king", false);

//    EEPROM.begin(3512);
 //  starline_codePAK2[0]=EEPROM.read(30);
 starline_codePAK2[0]= prefs.getUChar("sta10", 0);
//  starline_codePAK2[1]=EEPROM.read(31);
 starline_codePAK2[1]= prefs.getUChar("sta11", 0);
//   starline_codePAK2[2]=EEPROM.read(32);
 starline_codePAK2[2]= prefs.getUChar("sta12", 0);
//   starline_codePAK2[3]=EEPROM.read(33);
 starline_codePAK2[3]= prefs.getUChar("sta13", 0);
//   starline_codePAK2[4]=EEPROM.read(34);
 starline_codePAK2[4]= prefs.getUChar("sta14", 0);
 //  starline_codePAK2[5]=EEPROM.read(35);
  starline_codePAK2[5]= prefs.getUChar("sta15", 0);
 //  starline_codePAK2[6]=EEPROM.read(36);
  starline_codePAK2[6]= prefs.getUChar("sta16", 0);
 //  starline_codePAK2[7]=EEPROM.read(37);
  starline_codePAK2[7]= prefs.getUChar("sta17", 0);
 //  starline_codePAK2[8]=EEPROM.read(38);
  starline_codePAK2[8]= prefs.getUChar("sta18", 0);
prefs.end();

 starline_sendPAK2(starline_codePAK2);


  sending="code star_line:"+String(   starline_codePAK2[0],HEX);
sending=sending+String(   starline_codePAK2[1],HEX);
sending=sending+String(   starline_codePAK2[2],HEX);
sending=sending+String(   starline_codePAK2[3],HEX);
sending=sending+String(  starline_codePAK2[4],HEX);
sending=sending+String(   starline_codePAK2[5],HEX);
sending=sending+String(  starline_codePAK2[6],HEX);
sending=sending+String(   starline_codePAK2[7],HEX);
sending=sending+String(   starline_codePAK2[8],HEX);



 
 
  digitalWrite(TX, HIGH);
  delay(100);
  digitalWrite(TX, LOW);


 
   
  starline_state = 0;
// for(int i = 0; i<9; i++){
//    starline_code[i]=0;
 // }
 
 
  }








void posilkeeloq1zapis(){

 
////////////////////schet paketov
k = 0;
kk = 0;


//EEPROM.begin(3512);
 prefs.begin("esp32king", false);

 //keelog_codePAK1zapis[0]=EEPROM.read(50);
     keelog_codePAK1zapis[0]=prefs.getUChar("keez0", 0);
 // keelog_codePAK1zapis[1]=EEPROM.read(51);
 keelog_codePAK1zapis[1]=prefs.getUChar("keez1", 0);
 //  keelog_codePAK1zapis[2]=EEPROM.read(52);
 keelog_codePAK1zapis[2]=prefs.getUChar("keez2", 0);
 //  keelog_codePAK1zapis[3]=EEPROM.read(53);
 keelog_codePAK1zapis[3]=prefs.getUChar("keez3", 0);
 //  keelog_codePAK1zapis[4]=EEPROM.read(54);
 keelog_codePAK1zapis[4]=prefs.getUChar("keez4", 0);
 //  keelog_codePAK1zapis[5]=EEPROM.read(55);
 keelog_codePAK1zapis[5]=prefs.getUChar("keez5", 0);
 //  keelog_codePAK1zapis[6]=EEPROM.read(56);
 keelog_codePAK1zapis[6]=prefs.getUChar("keez6", 0);
 //  keelog_codePAK1zapis[7]=EEPROM.read(57);
 keelog_codePAK1zapis[7]=prefs.getUChar("keez7", 0);
 //  keelog_codePAK1zapis[8]=EEPROM.read(58);
 keelog_codePAK1zapis[8]=prefs.getUChar("keez8", 0);

prefs.end();
    keelog_send(keelog_codePAK1zapis);
 
  digitalWrite(TX, HIGH);
  delay(100);
  digitalWrite(TX, LOW);



//vibros na displey

 
   
  keelog_state = 0;
// for(int i = 0; i<9; i++){
//    keelog_code[i]=0;}

//Serial.println("srabotalo-keeloq");
   
}


void posilkeeloq2zapis(){
 
////////////////////schet paketov
k = 0;
kk = 0;


//EEPROM.begin(3512);

  prefs.begin("esp32king", false);
 //keelog_codePAK2zapis[0]=EEPROM.read(60);

 keelog_codePAK2zapis[0]=prefs.getUChar("keez10", 0);
 // keelog_codePAK2zapis[1]=EEPROM.read(61);
  keelog_codePAK2zapis[1]=prefs.getUChar("keez11", 0);
 //  keelog_codePAK2zapis[2]=EEPROM.read(62);
  keelog_codePAK2zapis[2]=prefs.getUChar("keez12", 0);
 //  keelog_codePAK2zapis[3]=EEPROM.read(63);
  keelog_codePAK2zapis[3]=prefs.getUChar("keez13", 0);
 //  keelog_codePAK2zapis[4]=EEPROM.read(64);
  keelog_codePAK2zapis[4]=prefs.getUChar("keez14", 0);
 //  keelog_codePAK2zapis[5]=EEPROM.read(65);
  keelog_codePAK2zapis[5]=prefs.getUChar("keez15", 0);
 //  keelog_codePAK2zapis[6]=EEPROM.read(66);
  keelog_codePAK2zapis[6]=prefs.getUChar("keez16", 0);
 //  keelog_codePAK2zapis[7]=EEPROM.read(67);
  keelog_codePAK2zapis[7]=prefs.getUChar("keez17", 0);
  // keelog_codePAK2zapis[8]=EEPROM.read(68);
   keelog_codePAK2zapis[8]=prefs.getUChar("keez18", 0);

prefs.end();
    keelog_send(keelog_codePAK2zapis);
 
  digitalWrite(TX, HIGH);
  delay(100);
  digitalWrite(TX, LOW);



//vibros na displey

 
   
  keelog_state = 0;
// for(int i = 0; i<9; i++){
//    keelog_code[i]=0;}

Serial.println("srabotalo-keeloq");
   
}





 void posilstarline1zapis(){


////////////////////schet paketov
k = 0;
kk = 0;
 
//EEPROM.begin(3512);

 prefs.begin("esp32king", false);
   
  // starline_codePAK1zapis[0]=EEPROM.read(80);
   starline_codePAK1zapis[0]=prefs.getUChar("starz10", 0);
 // starline_codePAK1zapis[1]=EEPROM.read(81);
  starline_codePAK1zapis[1]=prefs.getUChar("starz11", 0);
 //  starline_codePAK1zapis[2]=EEPROM.read(82);
  starline_codePAK1zapis[2]=prefs.getUChar("starz12", 0);
//   starline_codePAK1zapis[3]=EEPROM.read(83);
starline_codePAK1zapis[3]=prefs.getUChar("starz13", 0);
//   starline_codePAK1zapis[4]=EEPROM.read(84);
starline_codePAK1zapis[4]=prefs.getUChar("starz14", 0);
//   starline_codePAK1zapis[5]=EEPROM.read(85);
starline_codePAK1zapis[5]=prefs.getUChar("starz15", 0);
//   starline_codePAK1zapis[6]=EEPROM.read(86);
starline_codePAK1zapis[6]=prefs.getUChar("starz16", 0);
//   starline_codePAK1zapis[7]=EEPROM.read(87);
starline_codePAK1zapis[7]=prefs.getUChar("starz17", 0);
//   starline_codePAK1zapis[8]=EEPROM.read(88);
starline_codePAK1zapis[8]=prefs.getUChar("starz18", 0);

prefs.end();
 starline_sendPAK2(starline_codePAK1zapis);



 
 
//  digitalWrite(TX, HIGH);
//  delay(100);
//  digitalWrite(TX, LOW);


 
   
  starline_state = 0;
 //for(int i = 0; i<9; i++){
//    starline_code[i]=0;
//  }
  }
 




 void posilstarline2zapis(){

 
////////////////////schet paketov
k = 0;
kk = 0;

///    EEPROM.begin(3512);


 prefs.begin("esp32king", false);
 



 starline_codePAK2zapis[0]=prefs.getUChar("starz0", 0);
//  starline_codePAK2zapis[1]=EEPROM.read(71);
 starline_codePAK2zapis[1]=prefs.getUChar("starz1", 0);
 //  starline_codePAK2zapis[2]=EEPROM.read(72);
  starline_codePAK2zapis[2]=prefs.getUChar("starz2", 0);
 ///  starline_codePAK2zapis[3]=EEPROM.read(73);
  starline_codePAK2zapis[3]=prefs.getUChar("starz3", 0);
 ///  starline_codePAK2zapis[4]=EEPROM.read(74);
  starline_codePAK2zapis[4]=prefs.getUChar("starz4", 0);
 //  starline_codePAK2zapis[5]=EEPROM.read(75);
   starline_codePAK2zapis[5]=prefs.getUChar("starz5", 0);
 ///  starline_codePAK2zapis[6]=EEPROM.read(76);
   starline_codePAK2zapis[6]=prefs.getUChar("starz6", 0);
 ///  starline_codePAK2zapis[7]=EEPROM.read(77);
   starline_codePAK2zapis[7]=prefs.getUChar("starz7", 0);
 ///  starline_codePAK2zapis[8]=EEPROM.read(78);
   starline_codePAK2zapis[8]=prefs.getUChar("starz8", 0);

prefs.end();

 starline_sendPAK2(starline_codePAK2zapis);



 
 
 // digitalWrite(TX, HIGH);
 // delay(100);
 // digitalWrite(TX, LOW);


 
   
  starline_state = 0;
// for(int i = 0; i<9; i++){
//    starline_code[i]=0;
//  }
 
  }
 

////////////////////////////////////WIIIIIIIIIIIFIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII///////////////////////////






У вас нет необходимых прав для просмотра вложений в этом сообщении.

Аватар пользователя
admin
Администратор
Сообщений: 154
Зарегистрирован: 10 июн 2017, 16:49
Откуда: Rakun City
Контактная информация:

Re: ESP#32 wemos with lcd

Сообщение admin » 18 апр 2018, 10:55

ESP32-KINGWIFI-VERY-FIX-BUGS-BUNNY.rar

первая это самая оптимальная прошивк4а на данный момент ,пофиксил баги с памятью итд,пишет коды,и прочие
и вроде бы даже не зависает 8-)
а зависала она похоже изза неверного использования памяти :?

а это самая бомба,которая позволяет вводит коды и строчки через форму и выдавать их в эфир :mrgreen:
ESP32-KINGWIFI-VERY-FIX-BUGS-BUNNY_GET_WEBDONE.rar
она самая 8-)



Screenshot_2018-04-20-08-33-51.png




ESP32-KINGWIFI-DONE-may_lcd.rar


Esp32-rev1-0-96-oled-Arduino-esp32-OLED-Wi-Fi-Bluetooth.jpg_640x640.jpg



не разу не завис как lcd подключил 8-)


брут шлаков есть,и прием тоже в этом исходнике ,и вроде даже выброс,не проверял :mrgreen:

ESP32-KINGWIFI-DONE-may_lcd_brutshlak_shlak_priem_vibros.rar



IMG_20180419_081012.jpg


в анализатор пакеты бросает :mrgreen:

этот код более доделанный и запоминает шлакбаум последний в память
ESP32-KINGWIFI-ZAPSHLAK.rar
У вас нет необходимых прав для просмотра вложений в этом сообщении.

Nisssm0
Сообщений: 40
Зарегистрирован: 28 янв 2018, 00:08
Контактная информация:

Re: ESP#32 Сканер для вай фай начало,на базе кинга,но экономия на дисплеях ,кнопках,и вообще намного упрощенный вариант)

Сообщение Nisssm0 » 30 апр 2018, 11:57

Привет админ хочу замутить твой граб!
вопрос в чем ?
что конкретно нужно для него ?
1. esp32 oled
2. какой приемо-передатчик ?
3. и плата с кнопкой и паролем ?
а дальше не пойму

Аватар пользователя
admin
Администратор
Сообщений: 154
Зарегистрирован: 10 июн 2017, 16:49
Откуда: Rakun City
Контактная информация:

Re: ESP#32 Сканер для вай фай начало,на базе кинга,но экономия на дисплеях ,кнопках,и вообще намного упрощенный вариант)

Сообщение admin » 30 апр 2018, 14:47

Nisssm0 писал(а):Привет админ хочу замутить твой граб!
вопрос в чем ?
что конкретно нужно для него ?
1. esp32 oled
2. какой приемо-передатчик ?
3. и плата с кнопкой и паролем ?
а дальше не пойму

1.во первый есть для есп8266 тема рядом,любая есп32 с базой мцю теоретически подходит
2.любые приемопередатчики с логикой 3 вольта подойдут
3.кнопки не обязательно ,это тема лайт версии ,она по вай фай работает,и управляется через точку доступа или с телефона или компьютера 8-)
и вобще бери 8266 лучше на ней полный угар :mrgreen: ,а 32 только вышла на ней не все работает как надо,да и код переписывать долго


Вернуться в «KING-GRABBER»

Кто сейчас на форуме

Количество пользователей, которые сейчас просматривают этот форум: нет зарегистрированных пользователей и 0 гостей