Показать сообщение отдельно
Старый 05.06.2019, 13:47   #92
СаняЧ
Резидент клуба
 
Аватар для СаняЧ
 
Регистрация: 08.05.2011
Сообщений: 450
Exclamation Re: управление с обратной связью на базе брелока старлайн

Цитата:
Сообщение от DIVER_SANT
Достал с полки свой проект и прилепил к нему ответ на брелок,то бишь при приходе команды с брела на ардуино-в ответку посылает 48 бит обратки подтверждая прием,брелок пищит подтверждая приход обратки

переделал код под свой брелок TW-9010
Но пока результат отрицательный видимо у моих брелков другие коды
Пока только светодиодом играюсь
Разбираюсь дальше с обраткой...

Код:
/*
 * управление с обратной связью на базе брелока старлайн
 * http://phreakerclub.com/forum/showthread.php?t=1656&page=10
 * 
 */

#define RX 2
#define txPin 10
int starlineCounter = 0;
//byte starline_code[6]={0x1B,0xAA, 0x72, 0x58,0x40, 0x04};//пакет 48 бит обратки(последние биты отвечают задлину мелодии,в даннм случае 0х04)
//byte starline_code[6]={0x1B,0xAA,0x20,0x00,0x04,0x40};//пакет 48 бит обратки
byte starline_code[6]={0x1B,0xAA,0x20,0x10,0xA4,0x40};//пакет 48 бит обратки S0 S1 00 00 00 S2

  unsigned char brel_off[4] = {0x1B ,0xAA, 0x40,0x02 };// кнопка 1
   unsigned char brel_on[4] = {0x1B ,0xAA, 0x40,0x04 };// кнопка 2
volatile byte level=255;
volatile unsigned long last, len;
byte p_level;
unsigned long p_len, p_len_prev;

struct
{
  byte state;
  unsigned long TE;
  byte pre_count, data[8], dat_bit;
} keeloq;

struct
{
  byte state;
  byte pre_count, data[8], dat_bit;
} starline;

void setbit(byte *data, byte n)
{
  data[n/8]|=1<<(n%8);
}

#define KL_MIN_PRE_COUNT 4
#define KL_MAX_TE 660//500 //660original
#define KL_MIN_TE 260//300 //260original
#define KL_MAX_BITS 64

void process_keeloq()
{
  int i, b;
  unsigned char input;
  switch (keeloq.state)
  {
    case 0:
      if (p_level) break;
      keeloq.state = 1;
      keeloq.pre_count = 0;
      break;

    case 1: //pre+hdr
      if (p_len >= KL_MIN_TE && p_len <= KL_MAX_TE) keeloq.pre_count++;
      else if (!p_level && p_len >= KL_MIN_TE * 10 && p_len <= KL_MAX_TE * 10 && keeloq.pre_count >= KL_MIN_PRE_COUNT)
      {
        keeloq.TE = p_len / 10;
        keeloq.state = 2;
        keeloq.dat_bit = 0;
        keeloq.data[0] = 0x00;
        keeloq.data[1] = 0x00;
        keeloq.data[2] = 0x00;
        keeloq.data[3] = 0x00;
        keeloq.data[4] = 0x00;
        keeloq.data[5] = 0x00;
        keeloq.data[6] = 0x00;
        keeloq.data[7] = 0x00;
      }
      else
      {
        keeloq.state = 0;
        break;
      }
      break;

    case 2: //dat
      if (!p_level) break;

      if (p_len < keeloq.TE / 2 || p_len > keeloq.TE * 3)
      {
        keeloq.state = 0;
        break;
      }

      if (p_len <= keeloq.TE + keeloq.TE / 2) keeloq.data[keeloq.dat_bit / 8] |= (1 << (7 - keeloq.dat_bit % 8)); // setbit(keeloq.data, keeloq.dat_bit);
      if (++keeloq.dat_bit == KL_MAX_BITS)
      {
        /*
          // // Алгоритм Инвесии Порядка Битов by BlackPhreaker
          for(b=0; b!=9; b++ )
           {
           input = keeloq.data[b];
           keeloq.data[b] = 0;
           for( i = 0; i!=8; ++i)
               {
                 keeloq.data[b] |= ((input>>i)&1)<<(8-1-i);
               }
           }
          // Окончание Инвесии Битов by BlackPhreaker
        */
        keeloq.state = 100;
      }
      break;
  }
}

#define SL_MIN_PRE_COUNT 4
#define SL_MAX_PRE 1150
#define SL_MIN_PRE 850
#define SL_MAX_ZERO 350
#define SL_MIN_ZERO 100
#define SL_MAX_ONE 700
#define SL_MIN_ONE 400
#define SL_MIN_BITS 16
#define SL_MAX_BITS 64

void process_starline()
{
  byte b;

  switch(starline.state)
  {
    case 0:
      if(p_level) break;
      starline.state=1;
      starline.pre_count=0;
      break;

    case 1: //pre
      if(p_len>=SL_MIN_PRE && p_len<=SL_MAX_PRE) starline.pre_count++;
      else if(p_len<SL_MIN_PRE && starline.pre_count>=SL_MIN_PRE_COUNT)
      {
        starline.state=2;
        starline.dat_bit=0;
        starline.data[0]=0x00;
        starline.data[1]=0x00;
        starline.data[2]=0x00;
        starline.data[3]=0x00;
        starline.data[4]=0x00;
        starline.data[5]=0x00;
        starline.data[6]=0x00;
        starline.data[7]=0x00;
      }
        else
      {
        starline.state=0;
        break;
      }
      break;

    case 2: //dat
      if(p_level) break;
      
      if(p_len_prev>=SL_MIN_ONE && p_len_prev<=SL_MAX_ONE &&
         p_len>=SL_MIN_ONE && p_len<=SL_MAX_ONE) b=1;
       else
      if(p_len_prev>=SL_MIN_ZERO && p_len_prev<=SL_MAX_ZERO &&
         p_len>=SL_MIN_ZERO && p_len<=SL_MAX_ZERO) b=0;
      else
      {
        if(starline.dat_bit>=SL_MIN_BITS) starline.state=100;
          else starline.state=0;
        break;
      }

      if(b) setbit(starline.data, starline.dat_bit);
      if(++starline.dat_bit==SL_MAX_BITS) starline.state=100;
      break;
    
  }
}

void dump_hex(byte *buf, byte bits)
{
  byte a;
  
  for(a=0; a<(bits+7)/8; a++)
  {
    if(buf[a]<=0x0f) Serial.print('0');
    Serial.print(buf[a], HEX);
    Serial.print(" ");   
         
  }
  Serial.println("");
}

void rx_int()
{
  if(level!=255) return;
  
  len=micros()-last;
  last=micros();
  
  if(digitalRead(RX)==HIGH) level=0;
    else level=1; 
}

void setup()
{ 
  
   pinMode(txPin, OUTPUT);
   pinMode(13, OUTPUT);
  
  attachInterrupt(0, rx_int, CHANGE);
  
  Serial.begin(115200); 
  while(!Serial);

  Serial.println(" ARDUINO LOGGER BY HUY ");
  Serial.println("");
    
  interrupts();

  sl_send(); // SEND MY CODE
} 

byte a;

void loop()
{ 
  if(level!=255)
  {
    noInterrupts();
    p_level=level;
    p_len=len;
    len=0;
    level=255;
    interrupts();      
    process_starline();
    process_keeloq();    
    p_len_prev=p_len;
  } 
/*  
  if (keeloq.state == 100)
  {
    Serial.print("KeeLoq ");
    //dump_hex(keeloq.data, 64);
    Serial.print("HOP:");
    Serial.print(keeloq.data[0], HEX);
    Serial.print(keeloq.data[1], HEX);
    Serial.print(keeloq.data[2], HEX);
    Serial.print(keeloq.data[3], HEX);
    Serial.print(" ");
    Serial.print("FIX:");
    Serial.print(keeloq.data[4], HEX);
    Serial.print(keeloq.data[5], HEX);
    Serial.print(keeloq.data[6], HEX);
    Serial.print(" ");
    Serial.print("BTN:");
    Serial.print(keeloq.data[7], HEX);
    Serial.print("\n");
    Serial.print("KeeLoq: ");
    dump_hex(keeloq.data, 64);
    //Serial.print(" ");

    keeloq.state = 0;
  }
*/  
  //if(starline.state==100)
  if(keeloq.state==100)
  {        
    //Serial.print("STARLINE[");
    Serial.print("KEELOQ[");
    //Serial.print(starline.dat_bit);
    Serial.print(keeloq.dat_bit);
    Serial.print("]: ");
    //dump_hex(starline.data, starline.dat_bit);
    dump_hex(keeloq.data, keeloq.dat_bit);
    //starline.state=0;
    keeloq.state=0;
 //Serial.print(" ");
//Serial.print(brel[0], HEX); Serial.print(" ");
//Serial.print(brel[1], HEX); Serial.print(" ");
//Serial.print(brel[2], HEX); Serial.print(" ");
     //if ( starline.data[4]==brel_on[0] && starline.data[5]==brel_on[1] && starline.data[6]==brel_on[2]&& starline.data[7]==brel_on[3] ) {
     if ( keeloq.data[4]==brel_on[0] && keeloq.data[5]==brel_on[1] && keeloq.data[6]==brel_on[2]&& keeloq.data[7]==brel_on[3] ){

       digitalWrite(13, HIGH); // УРА нашел свой брел 
  Serial.println("Light ON ");
  delay(500);
   sl_send();// посылаем ответку на брелок
} else {
  //if ( starline.data[4]==brel_off[0] && starline.data[5]==brel_off[1] && starline.data[6]==brel_off[2]&& starline.data[7]==brel_off[3] ){
  if ( keeloq.data[4]==brel_off[0] && keeloq.data[5]==brel_off[1] && keeloq.data[6]==brel_off[2]&& keeloq.data[7]==brel_off[3] ){
    
  digitalWrite(13, LOW); // вот блин, летают тут всякие
  Serial.println("Light OFF ");
  delay(500);
  sl_send();//посылаем ответку на брелок
}

}
    
  } 
  }
void send_meander(int time){
  digitalWrite(txPin, HIGH);
  delayMicroseconds(time);
  digitalWrite(txPin, LOW);
  delayMicroseconds(time);
}

void sl_send(){// посылаем команду  обратки
  //for(int i = 0; i<9; i++){
  //for(int i = 0; i<50; i++){
  for(int i = 0; i<9; i++){
    starline_send( starline_code);
  }
}
  void starline_send(byte* starline_code){
 
  for(int i = 0; i<6; i++){//посылаем преамблу
    send_meander(1000);
  }
  for( int i = 0; i<6; i++){
   
      for(int i2 = 0; i2<8; i2++){
        if(!bitRead(starline_code[i], i2)){
          send_meander(250);
        }
        else{
          send_meander(500);
        }
      }
  }
  }
__________________
Фрикерам везде дорога!!! Фрикерам везде почет!!!
SMD придумали те, кому в плате под DIP дырки сверлить лень...
Ни Одна Система НЕ Является ЗАЩИЩЕННОЙ...
СаняЧ вне форума   Ответить с цитированием