Fórum témák

» Több friss téma
Fórum » KEELOQ - Miértek, hogyanok
 
Témaindító: NeoCorteX, idő: Feb 20, 2009
Lapozás: OK   2 / 2
(#) phr3ak válasza tneilc hozzászólására (») Dec 16, 2016 /
 
Elsősorban komplett hw-t keresek megvételre. Persze meglehet próbálni, hogy a fenti kódok egyik-e jó-e valamelyik "kínai" vevőbe amit a neten árulnak, de ez így kissé bizonytalan.
(#) phr3ak hozzászólása Dec 26, 2016 /
 
Sajnos az MPLAB X keeloq pluginja nem támogatja a HCS512 beprogramozását. A régi MPLAB keeloq pluginja támogatja, viszont olyat kér, hogy custodian key 1A és custodian key 1B ezek feltehetően két 16 karakteres hexadecimális szám, tehát összesen 128 bit. Ezt nem tudom, hova tenni, mivel a manufacturer key 64 bit. Erről van tudomásotok mi ez?
(#) phr3ak hozzászólása Jan 4, 2017 /
 
közben megtaláltam a két custodian key xor-olva adja a manufacturer key-t
(#) phr3ak hozzászólása Jan 14, 2017 /
 
Sajnos nem találom a hcs-t hogy kell összekötni a pickittel?
(#) pipi válasza phr3ak hozzászólására (») Jan 14, 2017 /
 
Hali!
ha feltelepítetted a pickit 2 saját zoftverét, akkor megtalálod a readme-ben
pl nálam: Program Files\Microchip\PICkit 2 v2\PICkit 2 Readme.txt
(#) phr3ak hozzászólása Jan 14, 2017 /
 
A Pickit 3-nak is van ilyen saját szoftvere? Nekem az van...
(#) phr3ak hozzászólása Jan 16, 2017 /
 
Sajnos annak a readmejében nincs megnéztem...
(#) phr3ak hozzászólása Jan 16, 2017 /
 
Megtaláltam végül a PICkit 3 Programmer App and Scripting Tool v3.10 -ban Ha valakit érdekene, csatolom.

ReadMe.txt
    
(#) fepity hozzászólása Okt 23, 2019 /
 
Imént javitotam ki ezt a programot amit egy orosz oldalrol mentetem ki.
  1. #include "math.h" 
  2.  
  3.  
  4.  
  5. #define txPin 8
  6.  
  7. #define rxPin 7
  8.  
  9. #define signalPin 6
  10.  
  11.  
  12. int lastRxValue = 0;
  13.  
  14. int tempRxValue = 0;
  15.  
  16. unsigned long lastRxTime = 0;
  17.  
  18. unsigned long tempTime = 0;
  19.  
  20. unsigned long difTime = 0;
  21.  
  22. boolean bValidPacket = false;
  23.  
  24. int decodeMethod = 1; //0 real - as in manual, 1 inver as Oleg do
  25.  
  26.  
  27.  
  28. //Global vars end
  29.  
  30. void send_meander(int time){
  31.  
  32.   digitalWrite(txPin, HIGH);
  33.  
  34.   delayMicroseconds(time);
  35.  
  36.   digitalWrite(txPin, LOW);
  37.  
  38.   delayMicroseconds(time);
  39.  
  40. }
  41.  
  42. //keelog start
  43.  
  44. int keelog_state = 0;
  45.  
  46. int keelogCounter = 0;
  47.  
  48. byte keelog_code[9];
  49.  
  50.  
  51. void keelog_vardump(){
  52.  
  53.   if(decodeMethod == 0){
  54.  
  55. Serial.println("- keelog origin -");
  56. }else{
  57.  
  58. Serial.println("- keelog invert -");
  59.  
  60.   
  61.  
  62.   Serial.print(keelog_code[0], HEX);
  63.  
  64.   Serial.print(keelog_code[1], HEX);
  65.  
  66.   Serial.print(keelog_code[2], HEX);
  67.  
  68.   Serial.print(keelog_code[3], HEX);
  69.  
  70.   Serial.println("-hop");
  71.  
  72.   Serial.print(keelog_code[4], HEX);
  73.  
  74.   Serial.print(keelog_code[5], HEX);
  75.  
  76.   Serial.print(keelog_code[6], HEX);
  77.  
  78.   Serial.println("-fix");
  79.  
  80.   Serial.print(keelog_code[7], HEX);
  81.  
  82.   Serial.println("-btn");
  83.  
  84.   Serial.print(keelog_code[8], HEX);
  85.  
  86.   Serial.println("-dop");
  87.  
  88.   
  89.  
  90.   /*for(int i = 0; i<9; i++){
  91.  
  92.     Serial.print(keelog_code[i], HEX);
  93.  
  94.     Serial.print(" - ");
  95.  
  96.   }*/
  97.  
  98.   keelog_send(keelog_code);
  99.  
  100.   digitalWrite(signalPin, HIGH);
  101.  
  102.   delay(100);
  103.  
  104.   digitalWrite(signalPin, LOW);
  105.  
  106.   keelog_state = 0;
  107.  
  108.   for(int i = 0; i<9; i++){
  109.  
  110.     keelog_code[i]=0;
  111.  
  112.   
  113.  
  114. }
  115. }
  116.     }
  117.  
  118. void keelog_send(byte* keelog_code){
  119.  
  120.   Serial.println("- sending keelog -");
  121.  
  122.   for(int i = 0; i<9; i++){
  123.  
  124.     Serial.print(keelog_code[i], HEX);
  125.  
  126.     Serial.print(" - ");
  127.  
  128.   
  129.  
  130.   for(int i = 0; i<11; i++){//посылаем преамблу
  131.  
  132.     send_meander(400);
  133.  
  134.   
  135.  
  136.   digitalWrite(txPin, HIGH);
  137.  
  138.   delayMicroseconds(400);
  139.  
  140.   digitalWrite(txPin, LOW);
  141.  
  142.   delayMicroseconds(4000);//посылаем хедер
  143.  
  144.   
  145.  
  146.   for( int i = 0; i<9; i++){
  147.  
  148.     if(decodeMethod==1){
  149.  
  150.       for(int i2 = 7;i2>=0;i2--){
  151.  
  152.         if(bitRead(keelog_code[i], i2)){
  153.  
  154.           digitalWrite(txPin, HIGH);
  155.  
  156.           delayMicroseconds(400);
  157.  
  158.           digitalWrite(txPin, LOW);
  159.  
  160.           delayMicroseconds(2*400);
  161.  
  162.         
  163.  
  164.         }else{
  165.  
  166.           digitalWrite(txPin, HIGH);
  167.  
  168.           delayMicroseconds(2*400);
  169.  
  170.           digitalWrite(txPin, LOW);
  171.  
  172.           delayMicroseconds(400);
  173.  
  174.         
  175.  
  176.       
  177.  
  178.     
  179.  
  180.    
  181.  
  182.         for(int i2 = 0;i2<8;i2++){
  183.  
  184.           if(!bitRead(keelog_code[i], i2)){
  185.  
  186.             digitalWrite(txPin, HIGH);
  187.  
  188.             delayMicroseconds(400);
  189.  
  190.             digitalWrite(txPin, LOW);
  191.  
  192.             delayMicroseconds(2*400);
  193.  
  194.           
  195.  
  196.           }else{
  197.  
  198.             digitalWrite(txPin, HIGH);
  199.  
  200.             delayMicroseconds(2*400);
  201.  
  202.             digitalWrite(txPin, LOW);
  203.  
  204.             delayMicroseconds(400);
  205.  
  206.           
  207.  
  208.        } 
  209. }
  210.  }}}}}}
  211. }
  212.  
  213. void keelog_get(){
  214.  
  215.     bValidPacket = false;
  216.  
  217.     if(keelog_state==0){//ждем преамбулу и хедер
  218.  
  219.       if(difTime > 280 && difTime < 620 && lastRxValue != tempRxValue){
  220.  
  221.         keelogCounter ++;
  222.  
  223.       
  224.  
  225.       }else{
  226.  
  227.         if(keelogCounter==23){
  228.  
  229.           if(difTime>2800 && difTime<6200 && lastRxValue == 0){
  230.  
  231.             keelog_state=1;
  232.  
  233.           
  234.  
  235.         
  236.  
  237.        keelogCounter = 0;
  238.  
  239.       
  240.  
  241.     
  242.  
  243.     }else{
  244.                      if(keelog_state==1){// получаем биты
  245.  
  246.       if(difTime > 560 && difTime < 1240 && lastRxValue == 1){// получили 1
  247.  
  248.         if(decodeMethod==0){
  249.  
  250.           keelog_code[round(keelogCounter/8)] = (keelog_code[round(keelogCounter/8)]>>1)|B10000000;
  251.  
  252.         
  253.  
  254.         }else{
  255.  
  256.           keelog_code[round(keelogCounter/8)] = (keelog_code[round(keelogCounter/8)]<<1)|B00000000;
  257.  
  258.         
  259.  
  260.         bValidPacket = true;
  261.  
  262.       
  263.                                  if(difTime > 280 && difTime < 620 && lastRxValue == 1){
  264.  
  265.         if(decodeMethod==0){
  266.  
  267.           keelog_code[round(keelogCounter/8)] = (keelog_code[round(keelogCounter/8)]>>1)|B00000000;
  268.  
  269.         
  270.  
  271.         }else{
  272.  
  273.           keelog_code[round(keelogCounter/8)] = (keelog_code[round(keelogCounter/8)]<<1)|B00000001;
  274.  
  275.         
  276.  
  277.         bValidPacket = true;
  278.  
  279.       
  280.  
  281.       if(lastRxValue == 0){
  282.  
  283.       
  284.  
  285.      }else{
  286.  
  287.         keelog_state=1;
  288.  
  289.         keelogCounter = 0;
  290.  
  291.       
  292.  
  293.       
  294.  
  295.       if(bValidPacket){
  296.  
  297.         keelogCounter++;
  298.  
  299.         if(keelogCounter==66){
  300.  
  301.           keelog_vardump();
  302.  
  303.           keelogCounter = 0;
  304.  
  305.           keelog_state = 0;
  306.  
  307.         
  308.  
  309.       
  310.  
  311.     }
  312. }}}}}}}}}}}
  313. }
  314.  
  315. //keelog end
  316.  
  317.  
  318.  
  319. void setup() {                
  320.  
  321.   pinMode(txPin, OUTPUT);
  322.  
  323.   pinMode(rxPin, INPUT);
  324.  
  325.   pinMode(signalPin, OUTPUT);
  326.  
  327.   //
  328.  
  329.   Serial.begin(9600);
  330.  
  331.   Serial.println("start");
  332.  
  333.   lastRxValue = digitalRead(rxPin);
  334.  
  335.   lastRxTime = micros();
  336.  
  337.   
  338.  
  339.   //attachInterrupt(0, grab, CHANGE);
  340.  
  341. }
  342.  
  343.  
  344. void loop() {
  345.  
  346.   tempRxValue = digitalRead(rxPin);
  347.  
  348.   
  349.  
  350.   if(tempRxValue != lastRxValue){
  351.  
  352.     tempTime = micros();
  353.  
  354.     difTime = tempTime - lastRxTime;
  355.  
  356.     keelog_get();  
  357.  
  358.     lastRxTime = tempTime;
  359.  
  360.     lastRxValue = tempRxValue;
  361.  
  362.   
  363.  
  364. }
  365.  
  366. }

Még nem épitetem meg csak a programot javitotam.
A hozzászólás módosítva: Okt 23, 2019
(#) pipi válasza fepity hozzászólására (») Okt 23, 2019 / 1
 
És???
Mi a kérdés? Mi volt rossz benne? Mit javítottál?
(#) fepity hozzászólása Nov 5, 2019 /
 
Én a telefonomon az ArduinoDroid nevü progpamot használom .
Azota probálkoztam vele de még nincs eredmény.
(#) fepity hozzászólása Nov 5, 2019 /
 
Viszont egy másikat találtam.
Ez viszont müködik de csak részben vagyok megelégedve vele.
A hozzászólás módosítva: Nov 5, 2019
Következő: »»   2 / 2
Bejelentkezés

Belépés

Hirdetés
Lapoda.hu     XDT.hu     HEStore.hu